#!/bin/bash

# 高级文件同步管理器 v3.0
# 支持主主模式和主从模式
# 支持加密传输
# 作者：宋利军
# 版本：3.0

# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
PURPLE='\033[0;35m'
CYAN='\033[0;36m'
WHITE='\033[1;37m'
NC='\033[0m' # No Color

# 配置目录
CONFIG_DIR="/etc/sync_tool"
TASKS_DIR="$CONFIG_DIR/tasks"
LOG_DIR="/var/log/sync_tool"

# 创建必要的目录
mkdir -p "$CONFIG_DIR" "$TASKS_DIR" "$LOG_DIR"

# 加密相关函数
# 生成基于系统硬件信息的唯一密钥
generate_encryption_key() {
    local key_file="$CONFIG_DIR/.encryption_key"
    
    # 如果密钥文件已存在且有效，直接返回
    if [ -f "$key_file" ] && [ -s "$key_file" ]; then
        cat "$key_file"
        return 0
    fi
    
    # 生成基于系统硬件信息的唯一密钥
    local system_info=""
    
    # 获取CPU信息
    if [ -f "/proc/cpuinfo" ]; then
        system_info+=$(grep -m1 "model name" /proc/cpuinfo 2>/dev/null | cut -d: -f2 | tr -d ' ' || echo "")
    fi
    
    # 获取主板序列号
    if command -v dmidecode >/dev/null 2>&1; then
        system_info+=$(dmidecode -s system-serial-number 2>/dev/null | head -1 || echo "")
    fi
    
    # 获取MAC地址
    system_info+=$(ip link show 2>/dev/null | grep -o -E '([0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}' | head -1 || echo "")
    
    # 获取主机名
    system_info+=$(hostname 2>/dev/null || echo "")
    
    # 如果无法获取硬件信息，使用备用方案
    if [ -z "$system_info" ]; then
        system_info="sync_tool_fallback_key_$(date +%s)_$(whoami)"
    fi
    
    # 使用SHA-256生成32字节密钥
    local key=$(echo -n "$system_info" | sha256sum | cut -d' ' -f1)
    
    # 保存密钥到安全位置
    echo "$key" > "$key_file"
    chmod 600 "$key_file"
    
    echo "$key"
}

# AES-256-CBC加密函数
encrypt_data() {
    local plaintext="$1"
    local key="$2"
    
    # 生成随机IV
    local iv=$(openssl rand -hex 16)
    
    # 使用AES-256-CBC加密
    local encrypted=$(echo -n "$plaintext" | openssl enc -aes-256-cbc -a -A -K "$key" -iv "$iv" 2>/dev/null)
    
    if [ $? -eq 0 ] && [ -n "$encrypted" ]; then
        # 返回格式：iv:encrypted_data
        echo "${iv}:${encrypted}"
    else
        return 1
    fi
}

# AES-256-CBC解密函数
decrypt_data() {
    local encrypted_data="$1"
    local key="$2"
    
    # 分离IV和加密数据
    local iv=$(echo "$encrypted_data" | cut -d: -f1)
    local encrypted=$(echo "$encrypted_data" | cut -d: -f2-)
    
    # 解密
    local decrypted=$(echo "$encrypted" | openssl enc -aes-256-cbc -a -A -d -K "$key" -iv "$iv" 2>/dev/null)
    
    if [ $? -eq 0 ]; then
        echo "$decrypted"
    else
        return 1
    fi
}

# 加密敏感信息
encrypt_sensitive_info() {
    local data="$1"
    local key=$(generate_encryption_key)
    
    if [ -z "$key" ]; then
        echo -e "${RED}❌ 无法生成加密密钥${NC}" >&2
        return 1
    fi
    
    local encrypted=$(encrypt_data "$data" "$key")
    if [ $? -eq 0 ]; then
        echo "ENC:$encrypted"
    else
        echo -e "${RED}❌ 加密失败${NC}" >&2
        return 1
    fi
}

# 解密敏感信息
decrypt_sensitive_info() {
    local encrypted_data="$1"
    local key=$(generate_encryption_key)
    
    if [ -z "$key" ]; then
        echo -e "${RED}❌ 无法生成解密密钥${NC}" >&2
        return 1
    fi
    
    # 检查是否为加密数据
    if [[ "$encrypted_data" =~ ^ENC: ]]; then
        local data=$(echo "$encrypted_data" | sed 's/^ENC://')
        local decrypted=$(decrypt_data "$data" "$key")
        if [ $? -eq 0 ]; then
            echo "$decrypted"
        else
            echo -e "${RED}❌ 解密失败${NC}" >&2
            return 1
        fi
    else
        # 如果不是加密数据，直接返回原数据（向后兼容）
        echo "$encrypted_data"
    fi
}

# 安全加载配置文件（自动解密敏感信息）
safe_load_config() {
    local config_file="$1"
    
    if [ ! -f "$config_file" ]; then
        echo -e "${RED}❌ 配置文件不存在: $config_file${NC}" >&2
        return 1
    fi
    
    # 创建临时配置文件
    local temp_config=$(mktemp)
    
    # 调试信息
    echo -e "${CYAN}🔍 正在安全加载配置文件: $config_file${NC}" >&2
    
    # 读取原配置文件并处理加密数据
    while IFS= read -r line; do
        # 跳过注释和空行
        if [[ "$line" =~ ^[[:space:]]*# ]] || [[ -z "$line" ]]; then
            echo "$line" >> "$temp_config"
            continue
        fi
        
        # 检查是否包含敏感信息（密码字段）
        if [[ "$line" =~ ^(SERVER_[0-9]+|MASTER_SSH_PASSWORD|SLAVE_[0-9]+)= ]]; then
            # 提取变量名和值
            local var_name=$(echo "$line" | cut -d'=' -f1)
            local var_value=$(echo "$line" | cut -d'=' -f2- | sed 's/^"//;s/"$//')
            
            # 检查是否为加密数据
            if [[ "$var_value" =~ ^ENC: ]]; then
                # 解密数据
                echo -e "${CYAN}🔓 正在解密变量: $var_name${NC}" >&2
                local decrypted_value=$(decrypt_sensitive_info "$var_value")
                if [ $? -eq 0 ]; then
                    echo "${var_name}=\"$decrypted_value\"" >> "$temp_config"
                    echo -e "${GREEN}✅ 解密成功: $var_name${NC}" >&2
                else
                    echo -e "${YELLOW}⚠️  解密失败，使用原始值: $var_name${NC}" >&2
                    echo "$line" >> "$temp_config"
                fi
            else
                # 非加密数据，直接保存
                echo "$line" >> "$temp_config"
            fi
        else
            # 非敏感信息，直接保存
            echo "$line" >> "$temp_config"
        fi
    done < "$config_file"
    
    # 加载临时配置文件
    source "$temp_config"
    local load_result=$?
    
    # 清理临时文件
    rm -f "$temp_config"
    
    return $load_result
}

# 系统依赖检查
check_dependencies() {
    echo -e "${CYAN}🔍 检查系统依赖...${NC}"

    local missing_deps=()

    # 检查基本工具
    if ! command -v rsync &> /dev/null; then
        missing_deps+=("rsync")
    fi

    if ! command -v ssh &> /dev/null; then
        missing_deps+=("ssh")
    fi

    if ! command -v inotifywait &> /dev/null; then
        missing_deps+=("inotify-tools")
    fi

    if ! command -v expect &> /dev/null; then
        missing_deps+=("expect")
    fi

    # sshpass 用于无交互 SSH/ SCP 部署
    if ! command -v sshpass &> /dev/null; then
        missing_deps+=("sshpass")
    fi

    if ! command -v systemctl &> /dev/null; then
        missing_deps+=("systemd")
    fi

    # 检查加密工具
    if ! command -v openssl &> /dev/null; then
        missing_deps+=("openssl")
    fi

    if ! command -v sha256sum &> /dev/null; then
        missing_deps+=("coreutils")
    fi

    # 如果有缺失的依赖，尝试安装
    if [ ${#missing_deps[@]} -gt 0 ]; then
        echo -e "${YELLOW}⚠️  检测到缺失的依赖: ${missing_deps[*]}${NC}"
        echo -e "${CYAN}正在尝试安装...${NC}"

        if command -v yum &> /dev/null; then
            yum install -y "${missing_deps[@]}"
        elif command -v apt-get &> /dev/null; then
            apt-get update && apt-get install -y "${missing_deps[@]}"
        else
            echo -e "${RED}❌ 无法自动安装依赖，请手动安装以下工具：${NC}"
            echo -e "${WHITE}${missing_deps[*]}${NC}"
            echo -e "${CYAN}CentOS/RHEL: yum install -y ${missing_deps[*]}${NC}"
            echo -e "${CYAN}Ubuntu/Debian: apt-get install -y ${missing_deps[*]}${NC}"
            exit 1
        fi

        echo -e "${GREEN}✅ 依赖安装完成${NC}"
    else
        echo -e "${GREEN}✅ 所有依赖已满足${NC}"
    fi
}

# 执行依赖检查
check_dependencies

# 欢迎界面
show_welcome() {
    clear
    echo -e "${CYAN}"
    echo "╔══════════════════════════════════════════════════════════════╗"
    echo "║                                                              ║"
    echo "║                   高级文件同步管理器 v3.0                    ║"
    echo "║                                                              ║"
    echo "║                     主主模式 & 主从模式                      ║"
    echo "║                                                              ║"
    echo "║     主主模式：多台服务器双向同步，任意一台变化都会同步       ║"
    echo "║     主从模式：主机写操作，从机读操作，从机删除自动恢复       ║"
    echo "║                                                              ║"
    echo "║     一键部署：任意一台服务器配置即可完成所有服务器配置       ║"
    echo "║     一键管理：支持不同域网服务器、运行多任务的管理面板       ║"
    echo "║                                                              ║"
    echo "║                         作者：宋利军                         ║"
    echo "║                         版本：3.0                            ║"
    echo "╚══════════════════════════════════════════════════════════════╝"
    echo -e "${NC}"
}

# 主菜单
show_main_menu() {
    echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
    echo -e "${WHITE}请选择操作模式：${NC}"
    echo -e "${CYAN}1.${NC} ${WHITE}主主同步模式${NC}"
    echo -e "${CYAN}2.${NC} ${WHITE}主从同步模式${NC}"
    echo -e "${CYAN}3.${NC} ${WHITE}任务管理面板${NC}"
    echo -e "${CYAN}4.${NC} ${WHITE}系统状态检查${NC}"
    echo -e "${CYAN}5.${NC} ${WHITE}退出${NC}"
    echo -e "${CYAN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
}

# 主主模式配置
setup_master_master_mode() {
    echo -e "\n${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
    echo -e "${WHITE}🎯 主主模式配置${NC}"
    echo -e "${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"

    # 输入服务器数量
    echo -e "\n${CYAN}请输入参与主主同步的服务器数量：${NC}"
    read -p "服务器数量: " server_count

    if ! [[ "$server_count" =~ ^[0-9]+$ ]] || [ "$server_count" -lt 2 ]; then
        echo -e "${RED}❌ 服务器数量必须大于等于2${NC}"
        return
    fi

    # 收集服务器信息
    servers=()
    for ((i=1; i<=$server_count; i++)); do
        echo -e "\n${YELLOW}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
        echo -e "${WHITE}配置第 $i 台服务器：${NC}"

        while true; do
            read -p "服务器IP地址: " server_ip
            read -p "SSH端口 [默认22]: " ssh_port
            ssh_port=${ssh_port:-22}
            read -p "SSH用户名 [默认root]: " ssh_user
            ssh_user=${ssh_user:-root}
            read -s -p "SSH密码: " ssh_password
            echo

            if sshpass -p "$ssh_password" ssh -p "$ssh_port" \
                -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null \
                -o PreferredAuthentications=password,keyboard-interactive -o PubkeyAuthentication=no \
                -o ConnectTimeout=8 "$ssh_user@$server_ip" "echo ok" >/dev/null 2>&1; then
                servers+=("$server_ip:$ssh_port:$ssh_user:$ssh_password")
                break
            else
                echo -e "${RED}❌ 无法连接到 $server_ip:$ssh_port（用户: $ssh_user），请重新输入该服务器信息${NC}"
            fi
        done
    done

    # 输入同步目录
    echo -e "\n${YELLOW}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
    echo -e "${WHITE}配置同步目录：${NC}"
    echo -e "${CYAN}请输入要同步的目录路径（多个目录用空格分隔）：${NC}"
    read -p "同步目录: " sync_dirs

    # 通用：遍历所有服务器（主主）
    echo -e "\n${CYAN}校验并创建所有服务器上的同步目录（不存在则创建）...${NC}"
    for ((i=0; i<${#servers[@]}; i++)); do
        server_data="${servers[$i]}"
        server_ip=$(echo "$server_data" | cut -d: -f1)
        ssh_port=$(echo "$server_data" | cut -d: -f2)
        ssh_user=$(echo "$server_data" | cut -d: -f3)
        # 提取密码部分（可能包含加密数据中的冒号）
        ssh_password=$(echo "$server_data" | sed 's/^[^:]*:[^:]*:[^:]*://')
        for d in $sync_dirs; do
            sshpass -p "$ssh_password" ssh -p "$ssh_port" \
            -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null \
            -o PreferredAuthentications=password,keyboard-interactive -o PubkeyAuthentication=no \
            -o ConnectTimeout=8 "$ssh_user@$server_ip" "[ -d \"$d\" ] || mkdir -p \"$d\"" >/dev/null 2>&1 || true
        done
    done

    # 创建任务配置
    task_id=$(date +%s)
    task_name="master_master_$task_id"

    # 确保本地配置目录存在
    mkdir -p "$TASKS_DIR"

    cat > "$TASKS_DIR/$task_name.conf" << EOF
# 主主模式任务配置
TASK_NAME="$task_name"
SYNC_MODE="master_master"
SERVER_COUNT=$server_count
SYNC_DIRS="$sync_dirs"
CREATED_TIME="$(date '+%Y-%m-%d %H:%M:%S')"
EOF

    # 保存服务器信息（密码部分加密）
    for ((i=0; i<${#servers[@]}; i++)); do
        server_data="${servers[$i]}"
        server_ip=$(echo "$server_data" | cut -d: -f1)
        ssh_port=$(echo "$server_data" | cut -d: -f2)
        ssh_user=$(echo "$server_data" | cut -d: -f3)
        # 提取密码部分（可能包含加密数据中的冒号）
        ssh_password=$(echo "$server_data" | sed 's/^[^:]*:[^:]*:[^:]*://')
        
        # 加密密码
        encrypted_password=$(encrypt_sensitive_info "$ssh_password")
        if [ $? -eq 0 ]; then
            echo "SERVER_$((i+1))=\"$server_ip:$ssh_port:$ssh_user:$encrypted_password\"" >> "$TASKS_DIR/$task_name.conf"
        else
            echo -e "${RED}❌ 密码加密失败，使用明文保存${NC}"
            echo "SERVER_$((i+1))=\"${servers[$i]}\"" >> "$TASKS_DIR/$task_name.conf"
        fi
    done

    # 二次校验配置文件是否生成
    if [ ! -f "$TASKS_DIR/$task_name.conf" ]; then
        echo -e "${RED}❌ 配置文件创建失败: $TASKS_DIR/$task_name.conf${NC}"
        return
    fi

    echo -e "\n${GREEN}✅ 主主模式配置已保存${NC}"
    echo -e "${CYAN}任务ID: $task_name${NC}"
    echo -e "${GREEN}🔐 服务器密码已加密存储${NC}"

    # 自动测试并打通免密
    echo -e "\n${CYAN}🔍 正在自动测试SSH连接并进行免密授权...${NC}"
    test_master_master_ssh "$task_name"

    # 校验并创建同步目录（如不存在则创建）
    echo -e "\n${CYAN}校验并创建所有服务器上的同步目录（不存在则创建）...${NC}"
    for ((i=0; i<${#servers[@]}; i++)); do
        server_data="${servers[$i]}"
        server_ip=$(echo "$server_data" | cut -d: -f1)
        ssh_port=$(echo "$server_data" | cut -d: -f2)
        ssh_user=$(echo "$server_data" | cut -d: -f3)
        # 提取密码部分（可能包含加密数据中的冒号）
        ssh_password=$(echo "$server_data" | sed 's/^[^:]*:[^:]*:[^:]*://')
        for d in $sync_dirs; do
            sshpass -p "$ssh_password" ssh -p "$ssh_port" \
                -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null \
                -o PreferredAuthentications=password,keyboard-interactive -o PubkeyAuthentication=no \
                -o ConnectTimeout=8 "$ssh_user@$server_ip" "[ -d \"$d\" ] || mkdir -p \"$d\"" >/dev/null 2>&1 || true
        done
    done

    # 复制配置文件到所有服务器（使用密钥免密方式）
    echo -e "\n${CYAN}正在复制配置文件到所有服务器（密钥方式）...${NC}"
    for ((i=0; i<${#servers[@]}; i++)); do
        local server_data="${servers[$i]}"
        local server_ip=$(echo "$server_data" | cut -d: -f1)
        local ssh_port=$(echo "$server_data" | cut -d: -f2)
        local ssh_user=$(echo "$server_data" | cut -d: -f3)

        local SSH_BASE="ssh -p $ssh_port -o StrictHostKeyChecking=no -o PasswordAuthentication=no -o ConnectTimeout=8"
        local SCP_BASE="scp -P $ssh_port -o StrictHostKeyChecking=no -o PasswordAuthentication=no -o ConnectTimeout=8"

        $SSH_BASE "$ssh_user@$server_ip" "mkdir -p /etc/sync_tool/tasks" >/dev/null 2>&1 || true
        $SCP_BASE "$TASKS_DIR/$task_name.conf" "$ssh_user@$server_ip:/etc/sync_tool/tasks/$task_name.conf" >/dev/null 2>&1 || {
            echo -e "${YELLOW}⚠️  配置文件复制到 ${server_ip} 失败（密钥未打通或SSH不可达），请稍后在任务管理中使用测试SSH功能排查${NC}"
        }
    done

    # 询问是否立即部署
    echo -e "\n${YELLOW}是否立即部署到所有服务器？${NC}"
    read -p "1.立即部署 2.稍后部署 [默认1]: " deploy_now
    deploy_now=${deploy_now:-1}

    if [ "$deploy_now" = "1" ]; then
        deploy_master_master_mode "$task_name"
    fi
}

# 部署主主模式
deploy_master_master_mode() {
    local task_name="$1"
    local config_file="$TASKS_DIR/$task_name.conf"

    if [ ! -f "$config_file" ]; then
        echo -e "${RED}❌ 任务配置文件不存在${NC}"
        return
    fi

    safe_load_config "$config_file"

    echo -e "\n${GREEN}🚀 开始部署主主模式到所有服务器...${NC}"

    # 为每台服务器部署环境
    for ((i=1; i<=$SERVER_COUNT; i++)); do
        local server_info="SERVER_$i"
        local server_data="${!server_info}"
        local server_ip=$(echo "$server_data" | cut -d: -f1)
        local ssh_port=$(echo "$server_data" | cut -d: -f2)
        local ssh_user=$(echo "$server_data" | cut -d: -f3)
        # 提取密码部分（可能包含加密数据中的冒号）
        local encrypted_password=$(echo "$server_data" | sed 's/^[^:]*:[^:]*:[^:]*://')
        local ssh_password=$(decrypt_sensitive_info "$encrypted_password")

        echo -e "\n${YELLOW}正在部署到服务器 $i: $server_ip${NC}"

        # 部署主主同步环境
        deploy_master_master_server "$server_ip" "$ssh_port" "$ssh_user" "$ssh_password" "$task_name"
    done

    echo -e "\n${GREEN}✅ 主主模式部署完成！${NC}"
    echo -e "${CYAN}🎯 所有服务器已配置双向同步，任意一台服务器的变化都会同步到其他服务器${NC}"
}

# 主从模式配置
setup_master_slave_mode() {
    echo -e "\n${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
    echo -e "${WHITE}🎯 主从模式配置${NC}"
    echo -e "${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"

    # 配置主机
    echo -e "\n${YELLOW}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
    echo -e "${WHITE}配置主机服务器：${NC}"

    while true; do
        read -p "主机IP地址: " master_ip
        read -p "主机SSH端口 [默认22]: " master_ssh_port
        master_ssh_port=${master_ssh_port:-22}
        read -p "主机SSH用户名 [默认root]: " master_ssh_user
        master_ssh_user=${master_ssh_user:-root}
        read -s -p "主机SSH密码: " master_ssh_password
        echo

        if sshpass -p "$master_ssh_password" ssh -p "$master_ssh_port" \
            -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null \
            -o PreferredAuthentications=password,keyboard-interactive -o PubkeyAuthentication=no \
            -o ConnectTimeout=8 "$master_ssh_user@$master_ip" "echo ok" >/dev/null 2>&1; then
            break
        else
            echo -e "${RED}❌ 无法连接到主机 $master_ip:$master_ssh_port（用户: $master_ssh_user），请重新输入主机信息${NC}"
        fi
    done

    # 配置从机
    echo -e "\n${YELLOW}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
    echo -e "${WHITE}配置从机服务器：${NC}"

    echo -e "${CYAN}请输入从机服务器数量：${NC}"
    read -p "从机数量: " slave_count

    if ! [[ "$slave_count" =~ ^[0-9]+$ ]] || [ "$slave_count" -lt 1 ]; then
        echo -e "${RED}❌ 从机数量必须大于等于1${NC}"
        return
    fi

    slaves=()
    for ((i=1; i<=$slave_count; i++)); do
        echo -e "\n${WHITE}配置第 $i 台从机：${NC}"
        while true; do
            read -p "从机IP地址: " slave_ip
            read -p "从机SSH端口 [默认22]: " slave_ssh_port
            slave_ssh_port=${slave_ssh_port:-22}
            read -p "从机SSH用户名 [默认root]: " slave_ssh_user
            slave_ssh_user=${slave_ssh_user:-root}
            read -s -p "从机SSH密码: " slave_ssh_password
            echo

            if sshpass -p "$slave_ssh_password" ssh -p "$slave_ssh_port" \
                -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null \
                -o PreferredAuthentications=password,keyboard-interactive -o PubkeyAuthentication=no \
                -o ConnectTimeout=8 "$slave_ssh_user@$slave_ip" "echo ok" >/dev/null 2>&1; then
                slaves+=("$slave_ip:$slave_ssh_port:$slave_ssh_user:$slave_ssh_password")
                break
            else
                echo -e "${RED}❌ 无法连接到从机 $slave_ip:$slave_ssh_port（用户: $slave_ssh_user），请重新输入该从机信息${NC}"
            fi
        done
    done

    # 输入同步目录
    echo -e "\n${YELLOW}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
    echo -e "${WHITE}配置同步目录：${NC}"
    echo -e "${CYAN}请输入要同步的目录路径（多个目录用空格分隔）：${NC}"
    read -p "同步目录: " sync_dirs

    # 校验并创建主机与从机上的同步目录（不存在则创建）
    echo -e "\n${CYAN}校验并创建主机与从机上的同步目录（不存在则创建）...${NC}"
    # 主机目录校验
    for d in $sync_dirs; do
        sshpass -p "$master_ssh_password" ssh -p "$master_ssh_port" \
            -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null \
            -o PreferredAuthentications=password,keyboard-interactive -o PubkeyAuthentication=no \
            -o ConnectTimeout=8 "$master_ssh_user@$master_ip" "[ -d \"$d\" ] || mkdir -p \"$d\"" >/dev/null 2>&1 || true
    done
    # 从机目录校验
    for ((i=0; i<${#slaves[@]}; i++)); do
        slave_data="${slaves[$i]}"
        slave_ip=$(echo "$slave_data" | cut -d: -f1)
        slave_ssh_port=$(echo "$slave_data" | cut -d: -f2)
        slave_ssh_user=$(echo "$slave_data" | cut -d: -f3)
        # 提取密码部分（可能包含加密数据中的冒号）
        slave_ssh_password=$(echo "$slave_data" | sed 's/^[^:]*:[^:]*:[^:]*://')
        for d in $sync_dirs; do
            sshpass -p "$slave_ssh_password" ssh -p "$slave_ssh_port" \
                -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null \
                -o PreferredAuthentications=password,keyboard-interactive -o PubkeyAuthentication=no \
                -o ConnectTimeout=8 "$slave_ssh_user@$slave_ip" "[ -d \"$d\" ] || mkdir -p \"$d\"" >/dev/null 2>&1 || true
        done
    done

    # 创建任务配置
    task_id=$(date +%s)
    task_name="master_slave_$task_id"

    # 加密主机密码
    encrypted_master_password=$(encrypt_sensitive_info "$master_ssh_password")
    if [ $? -ne 0 ]; then
        echo -e "${RED}❌ 主机密码加密失败，使用明文保存${NC}"
        encrypted_master_password="$master_ssh_password"
    fi
    
    cat > "$TASKS_DIR/$task_name.conf" << EOF
# 主从模式任务配置
TASK_NAME="$task_name"
SYNC_MODE="master_slave"
MASTER_IP="$master_ip"
MASTER_SSH_PORT="$master_ssh_port"
MASTER_SSH_USER="$master_ssh_user"
MASTER_SSH_PASSWORD="$encrypted_master_password"
SLAVE_COUNT=$slave_count
SYNC_DIRS="$sync_dirs"
CREATED_TIME="$(date '+%Y-%m-%d %H:%M:%S')"
EOF

    # 保存从机信息（密码部分加密）
    for ((i=0; i<${#slaves[@]}; i++)); do
        slave_data="${slaves[$i]}"
        slave_ip=$(echo "$slave_data" | cut -d: -f1)
        slave_port=$(echo "$slave_data" | cut -d: -f2)
        slave_user=$(echo "$slave_data" | cut -d: -f3)
        # 提取密码部分（可能包含加密数据中的冒号）
        slave_password=$(echo "$slave_data" | sed 's/^[^:]*:[^:]*:[^:]*://')
        
        # 加密密码
        encrypted_slave_password=$(encrypt_sensitive_info "$slave_password")
        if [ $? -eq 0 ]; then
            echo "SLAVE_$((i+1))=\"$slave_ip:$slave_port:$slave_user:$encrypted_slave_password\"" >> "$TASKS_DIR/$task_name.conf"
        else
            echo -e "${RED}❌ 从机密码加密失败，使用明文保存${NC}"
            echo "SLAVE_$((i+1))=\"${slaves[$i]}\"" >> "$TASKS_DIR/$task_name.conf"
        fi
    done

    echo -e "\n${GREEN}✅ 主从模式配置已保存${NC}"
    echo -e "${CYAN}任务ID: $task_name${NC}"
    echo -e "${GREEN}🔐 服务器密码已加密存储${NC}"

    # 自动测试并打通免密（主机⇄从机 双向）
    echo -e "\n${CYAN}🔍 正在自动测试SSH连接并进行免密授权（主机 ⇄ 从机）...${NC}"
    # 1) 确保主机存在密钥，并读取主机公钥
    MSSH_BASE="sshpass -p \"$master_ssh_password\" ssh -p $master_ssh_port -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o PreferredAuthentications=password,keyboard-interactive -o PubkeyAuthentication=no -o ConnectTimeout=8"
    $MSSH_BASE "$master_ssh_user@$master_ip" "mkdir -p ~/.ssh && chmod 700 ~/.ssh && [ -f ~/.ssh/id_rsa ] || ssh-keygen -t rsa -N \"\" -f ~/.ssh/id_rsa >/dev/null 2>&1" >/dev/null 2>&1 || true
    master_pub_key=$($MSSH_BASE "$master_ssh_user@$master_ip" "cat ~/.ssh/id_rsa.pub" 2>/dev/null)

    # 2) 遍历从机：为每个从机生成密钥（如无），写入主机公钥到从机 authorized_keys，并将从机公钥写入主机 authorized_keys
    for ((i=0; i<${#slaves[@]}; i++)); do
        slave_data="${slaves[$i]}"
        slave_ip=$(echo "$slave_data" | cut -d: -f1)
        slave_port=$(echo "$slave_data" | cut -d: -f2)
        slave_user=$(echo "$slave_data" | cut -d: -f3)
        # 提取密码部分（可能包含加密数据中的冒号）
        slave_pass=$(echo "$slave_data" | sed 's/^[^:]*:[^:]*:[^:]*://')

        SSSH_BASE="sshpass -p \"$slave_pass\" ssh -p $slave_port -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o PreferredAuthentications=password,keyboard-interactive -o PubkeyAuthentication=no -o ConnectTimeout=8"

        # 确保从机存在密钥
        $SSSH_BASE "$slave_user@$slave_ip" "mkdir -p ~/.ssh && chmod 700 ~/.ssh && [ -f ~/.ssh/id_rsa ] || ssh-keygen -t rsa -N \"\" -f ~/.ssh/id_rsa >/dev/null 2>&1" >/dev/null 2>&1 || true
        slave_pub_key=$($SSSH_BASE "$slave_user@$slave_ip" "cat ~/.ssh/id_rsa.pub" 2>/dev/null)

        # 将主机公钥写入从机（允许主机→从机 rsync）
        if [ -n "$master_pub_key" ]; then
            $SSSH_BASE "$slave_user@$slave_ip" "mkdir -p ~/.ssh && chmod 700 ~/.ssh && grep -qxF '$master_pub_key' ~/.ssh/authorized_keys 2>/dev/null || echo '$master_pub_key' >> ~/.ssh/authorized_keys && chmod 600 ~/.ssh/authorized_keys" >/dev/null 2>&1 || true
        fi

        # 将从机公钥写入主机（允许从机→主机 恢复/校验）
        if [ -n "$slave_pub_key" ]; then
            $MSSH_BASE "$master_ssh_user@$master_ip" "mkdir -p ~/.ssh && chmod 700 ~/.ssh && grep -qxF '$slave_pub_key' ~/.ssh/authorized_keys 2>/dev/null || echo '$slave_pub_key' >> ~/.ssh/authorized_keys && chmod 600 ~/.ssh/authorized_keys" >/dev/null 2>&1 || true
            # 将从机公钥也写入本机，确保从机→当前执行节点可免密（用于某些反向操作）
            mkdir -p ~/.ssh && chmod 700 ~/.ssh
            echo "$slave_pub_key" | grep -qxF -f - ~/.ssh/authorized_keys 2>/dev/null || echo "$slave_pub_key" >> ~/.ssh/authorized_keys
            chmod 600 ~/.ssh/authorized_keys 2>/dev/null || true
        fi
    done

    # 可选快速校验（密钥方式）
    ssh -p "$master_ssh_port" -o StrictHostKeyChecking=no -o PasswordAuthentication=no -o ConnectTimeout=5 "$master_ssh_user@$master_ip" echo ok >/dev/null 2>&1 || true
    for ((i=0; i<${#slaves[@]}; i++)); do
        slave_data="${slaves[$i]}"
        slave_ip=$(echo "$slave_data" | cut -d: -f1)
        slave_port=$(echo "$slave_data" | cut -d: -f2)
        slave_user=$(echo "$slave_data" | cut -d: -f3)
        ssh -p "$slave_port" -o StrictHostKeyChecking=no -o PasswordAuthentication=no -o ConnectTimeout=5 "$slave_user@$slave_ip" echo ok >/dev/null 2>&1 || true
    done

    # 确保本机到主机/从机的免密（用于后续本机 scp 分发配置）
    if [ ! -f "/root/.ssh/id_rsa" ]; then
        ssh-keygen -t rsa -N "" -f /root/.ssh/id_rsa >/dev/null 2>&1
    fi
    # 本机 → 主机 ssh-copy-id
    cat > /tmp/copy_key_master.exp << 'EXP_EOF'
#!/usr/bin/expect -f
set timeout 30
set ip [lindex $argv 0]
set port [lindex $argv 1]
set user [lindex $argv 2]
set password [lindex $argv 3]

spawn ssh-copy-id -p $port $user@$ip
expect {
    "yes/no" { send "yes\r"; exp_continue }
    "password:" { send "$password\r" }
}
expect eof
EXP_EOF
    expect /tmp/copy_key_master.exp "$master_ip" "$master_ssh_port" "$master_ssh_user" "$master_ssh_password" >/dev/null 2>&1 || true
    rm -f /tmp/copy_key_master.exp

    # 本机 → 各从机 ssh-copy-id
    for ((i=0; i<${#slaves[@]}; i++)); do
        slave_data="${slaves[$i]}"
        slave_ip=$(echo "$slave_data" | cut -d: -f1)
        slave_port=$(echo "$slave_data" | cut -d: -f2)
        slave_user=$(echo "$slave_data" | cut -d: -f3)
        slave_pass=$(echo "$slave_data" | cut -d: -f4)
        cat > /tmp/copy_key_slave.exp << 'EXP_EOF'
#!/usr/bin/expect -f
set timeout 30
set ip [lindex $argv 0]
set port [lindex $argv 1]
set user [lindex $argv 2]
set password [lindex $argv 3]

spawn ssh-copy-id -p $port $user@$ip
expect {
    "yes/no" { send "yes\r"; exp_continue }
    "password:" { send "$password\r" }
}
expect eof
EXP_EOF
        expect /tmp/copy_key_slave.exp "$slave_ip" "$slave_port" "$slave_user" "$slave_pass" >/dev/null 2>&1 || true
        rm -f /tmp/copy_key_slave.exp
    done

    # 通过密钥复制配置文件到主机与所有从机
    echo -e "\n${CYAN}正在复制配置文件到主机与所有从机（密钥方式）...${NC}"
    SSH_KEY_OPTS="-o StrictHostKeyChecking=no -o PasswordAuthentication=no -o ConnectTimeout=8"
    scp -P "$master_ssh_port" $SSH_KEY_OPTS "$TASKS_DIR/$task_name.conf" "$master_ssh_user@$master_ip:/etc/sync_tool/tasks/$task_name.conf" >/dev/null 2>&1 || true
    for ((i=0; i<${#slaves[@]}; i++)); do
        slave_data="${slaves[$i]}"
        slave_ip=$(echo "$slave_data" | cut -d: -f1)
        slave_port=$(echo "$slave_data" | cut -d: -f2)
        slave_user=$(echo "$slave_data" | cut -d: -f3)
        ssh -p "$slave_port" $SSH_KEY_OPTS "$slave_user@$slave_ip" "mkdir -p /etc/sync_tool/tasks" >/dev/null 2>&1 || true
        scp -P "$slave_port" $SSH_KEY_OPTS "$TASKS_DIR/$task_name.conf" "$slave_user@$slave_ip:/etc/sync_tool/tasks/$task_name.conf" >/dev/null 2>&1 || true
    done

    # 询问是否立即部署
    echo -e "\n${YELLOW}是否立即部署到所有服务器？${NC}"
    read -p "1.立即部署 2.稍后部署 [默认1]: " deploy_now
    deploy_now=${deploy_now:-1}

    if [ "$deploy_now" = "1" ]; then
        deploy_master_slave_mode "$task_name"
    fi
}

# 部署主从模式
deploy_master_slave_mode() {
    local task_name="$1"
    local config_file="$TASKS_DIR/$task_name.conf"

    if [ ! -f "$config_file" ]; then
        echo -e "${RED}❌ 任务配置文件不存在${NC}"
        return
    fi

    safe_load_config "$config_file"

    echo -e "\n${GREEN}🚀 开始部署主从模式...${NC}"

    # 部署主机
    echo -e "\n${YELLOW}正在部署主机: $MASTER_IP${NC}"
    deploy_master_server "$task_name"

    # 部署从机
    for ((i=1; i<=$SLAVE_COUNT; i++)); do
        local slave_info="SLAVE_$i"
        local slave_data="${!slave_info}"
        local slave_ip=$(echo "$slave_data" | cut -d: -f1)
        local ssh_port=$(echo "$slave_data" | cut -d: -f2)
        local ssh_user=$(echo "$slave_data" | cut -d: -f3)
        # 提取密码部分（可能包含加密数据中的冒号）
        local encrypted_password=$(echo "$slave_data" | sed 's/^[^:]*:[^:]*:[^:]*://')
        local ssh_password=$(decrypt_sensitive_info "$encrypted_password")

        echo -e "\n${YELLOW}正在部署从机 $i: $slave_ip${NC}"
        deploy_slave_server "$slave_ip" "$ssh_port" "$ssh_user" "$ssh_password" "$task_name"
    done

    echo -e "\n${GREEN}✅ 主从模式部署完成！${NC}"

    # 部署完成后，使用密钥对从机进行一次目录预创建与配置下发校验
    SSH_KEY_OPTS="-o StrictHostKeyChecking=no -o PasswordAuthentication=no -o ConnectTimeout=8"
    for ((i=1; i<=$SLAVE_COUNT; i++)); do
        local slave_info="SLAVE_$i"
        local slave_data="${!slave_info}"
        local slave_ip=$(echo "$slave_data" | cut -d: -f1)
        local ssh_port=$(echo "$slave_data" | cut -d: -f2)
        local ssh_user=$(echo "$slave_data" | cut -d: -f3)
        ssh -p "$ssh_port" $SSH_KEY_OPTS "$ssh_user@$slave_ip" "mkdir -p /etc/sync_tool/tasks && for d in $SYNC_DIRS; do mkdir -p \"$d\"; done" >/dev/null 2>&1 || true
        scp -P "$ssh_port" $SSH_KEY_OPTS "$TASKS_DIR/$task_name.conf" "$ssh_user@$slave_ip:/etc/sync_tool/tasks/$task_name.conf" >/dev/null 2>&1 || true
    done
}

# 任务管理面板
show_task_management() {
    while true; do
        clear
        echo -e "${CYAN}"
        echo -e "${GREEN}╔══════════════════════════════════════════════════════════════╗${NC}"
        echo -e "${GREEN}║${NC}                         ${WHITE}任务管理面板${NC}                         ${GREEN}║${NC}"
        echo -e "${GREEN}║${NC}                                                              ${GREEN}║${NC}"
        echo -e "${GREEN}║${NC}    ${WHITE} 1.${NC} ${CYAN}启动同步任务服务${NC}            ${WHITE} 6.${NC} ${CYAN}运行测试同步任务${NC}      ${GREEN}║${NC}"
        echo -e "${GREEN}║${NC}    ${WHITE} 2.${NC} ${CYAN}停止同步任务服务${NC}            ${WHITE} 7.${NC} ${CYAN}查看同步任务日志${NC}      ${GREEN}║${NC}"
        echo -e "${GREEN}║${NC}    ${WHITE} 3.${NC} ${CYAN}重启同步任务服务${NC}            ${WHITE} 8.${NC} ${CYAN}手动执行同步任务${NC}      ${GREEN}║${NC}"
        echo -e "${GREEN}║${NC}    ${WHITE} 4.${NC} ${CYAN}新建同步目录任务${NC}            ${WHITE} 9.${NC} ${CYAN}测试任务密钥连接${NC}      ${GREEN}║${NC}"
        echo -e "${GREEN}║${NC}    ${WHITE} 5.${NC} ${CYAN}列出所有任务列表${NC}            ${WHITE}10.${NC} ${CYAN}卸载所有同步服务${NC}      ${GREEN}║${NC}"
        echo -e "${GREEN}║${NC}                       ${WHITE} 0.${NC} ${RED}返回主菜单${NC}                         ${GREEN}║${NC}"
        echo -e "${GREEN}╚══════════════════════════════════════════════════════════════╝${NC}"
        echo
        read -p "请选择 [0-10]: " choice
        case $choice in
            1) start_sync_service ;;
            2) stop_sync_service ;;
            3) restart_sync_service ;;
            4) add_new_task ;;
            5) list_all_tasks ;;
            6) test_sync_task ;;
            7) view_service_logs ;;
            8) manual_sync ;;
            9) test_ssh_connection ;;
            10) uninstall_all_services ;;
            0) return ;;
            *) echo -e "${RED}❌ 无效选择${NC}" ;;
        esac
        echo -e "\n${YELLOW}按回车键继续...${NC}"
        read
    done
}

# 系统状态检查
check_system_status() {
    echo -e "\n${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
    echo -e "${WHITE}🔍 系统状态检查${NC}"
    echo -e "${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"

    # 检查必要工具
    echo -e "\n${CYAN}检查必要工具：${NC}"
    tools=("rsync" "ssh" "inotifywait" "systemctl")
    for tool in "${tools[@]}"; do
        if command -v "$tool" &> /dev/null; then
            echo -e "${GREEN}✅ $tool${NC}"
        else
            echo -e "${RED}❌ $tool${NC}"
        fi
    done

    # 检查服务状态
    echo -e "\n${CYAN}检查服务状态：${NC}"
    if systemctl is-active --quiet sync_tool; then
        echo -e "${GREEN}✅ 同步服务运行中${NC}"
    else
        echo -e "${RED}❌ 同步服务未运行${NC}"
    fi

    # 检查任务数量
    task_count=$(ls "$TASKS_DIR"/*.conf 2>/dev/null | wc -l)
    echo -e "\n${CYAN}当前任务数量：${NC} $task_count"

    # 检查磁盘空间
    echo -e "\n${CYAN}磁盘空间：${NC}"
    df -h / | tail -1 | awk '{print "总空间: " $2 " 已用: " $3 " 可用: " $4 " 使用率: " $5}'
}

# 辅助函数
deploy_to_server() {
    local ip="$1"
    local port="$2"
    local user="$3"
    local password="$4"
    local task_name="$5"

    echo -e "${CYAN}部署到 $ip:$port (用户: $user)${NC}"

    # 使用无交互部署方式，不再强依赖 expect

    # 创建expect脚本进行自动化部署
    cat > /tmp/deploy_script.exp << EOF
#!/usr/bin/expect -f
set timeout 30
set ip [lindex \$argv 0]
set port [lindex \$argv 1]
set user [lindex \$argv 2]
set password [lindex \$argv 3]
set task_name [lindex \$argv 4]

spawn ssh -p \$port \$user@\$ip

expect {
    "yes/no" { send "yes\r"; exp_continue }
    "password:" { send "\$password\r" }
}

expect "#"
send "mkdir -p /etc/sync_tool/tasks\r"
expect "#"
send "mkdir -p /var/log/sync_tool\r"
expect "#"

# 上传配置文件
send "exit\r"
expect eof
EOF

    # 执行expect脚本
    expect /tmp/deploy_script.exp "$ip" "$port" "$user" "$password" "$task_name"

    # 清理临时文件
    rm -f /tmp/deploy_script.exp

    echo -e "${GREEN}✅ 服务器 $ip 部署完成${NC}"
}

# 部署主主模式服务器
deploy_master_master_server() {
    local ip="$1"
    local port="$2"
    local user="$3"
    local password="$4"
    local task_name="$5"

    echo -e "${CYAN}部署主主同步到 $ip:$port (用户: $user)${NC}"

    # 检查expect是否可用
    if ! command -v expect &> /dev/null; then
        echo -e "${RED}❌ expect工具不可用，请确保已安装${NC}"
        return 1
    fi

    # 创建主主同步脚本内容
    cat > /tmp/sync_master_master.sh << 'SCRIPT_EOF'
#!/bin/bash
# 主主模式同步脚本

TASK_NAME="$1"
CONFIG_FILE="/etc/sync_tool/tasks/$TASK_NAME.conf"

if [ ! -f "$CONFIG_FILE" ]; then
    echo "配置文件不存在: $CONFIG_FILE"
    exit 1
fi

# 解密函数（用于远程服务器）
decrypt_remote_data() {
    local encrypted_data="$1"
    local key_file="/etc/sync_tool/.encryption_key"
    
    if [ ! -f "$key_file" ]; then
        echo "密钥文件不存在，尝试生成..." >&2
        # 生成密钥（简化版本）
        local system_info=""
        if [ -f "/proc/cpuinfo" ]; then
            system_info+=$(grep -m1 "model name" /proc/cpuinfo 2>/dev/null | cut -d: -f2 | tr -d ' ' || echo "")
        fi
        system_info+=$(hostname 2>/dev/null || echo "")
        system_info+=$(ip link show 2>/dev/null | grep -o -E '([0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}' | head -1 || echo "")
        
        if [ -z "$system_info" ]; then
            system_info="sync_tool_fallback_key_$(date +%s)"
        fi
        
        local key=$(echo -n "$system_info" | sha256sum | cut -d' ' -f1)
        echo "$key" > "$key_file"
        chmod 600 "$key_file"
    fi
    
    local key=$(cat "$key_file")
    
    if [[ "$encrypted_data" =~ ^ENC: ]]; then
        local data=$(echo "$encrypted_data" | sed 's/^ENC://')
        local iv=$(echo "$data" | cut -d: -f1)
        local encrypted=$(echo "$data" | cut -d: -f2-)
        local decrypted=$(echo "$encrypted" | openssl enc -aes-256-cbc -a -A -d -K "$key" -iv "$iv" 2>/dev/null)
        if [ $? -eq 0 ]; then
            echo "$decrypted"
        else
            echo "$encrypted_data"
        fi
    else
        echo "$encrypted_data"
    fi
}

# 安全加载配置
safe_load_remote_config() {
    local config_file="$1"
    local temp_config=$(mktemp)
    
    while IFS= read -r line; do
        if [[ "$line" =~ ^[[:space:]]*# ]] || [[ -z "$line" ]]; then
            echo "$line" >> "$temp_config"
            continue
        fi
        
        if [[ "$line" =~ ^(SERVER_[0-9]+|MASTER_SSH_PASSWORD|SLAVE_[0-9]+)= ]]; then
            local var_name=$(echo "$line" | cut -d'=' -f1)
            local var_value=$(echo "$line" | cut -d'=' -f2- | sed 's/^"//;s/"$//')
            
            if [[ "$var_value" =~ ^ENC: ]]; then
                local decrypted_value=$(decrypt_remote_data "$var_value")
                echo "${var_name}=\"$decrypted_value\"" >> "$temp_config"
            else
                echo "$line" >> "$temp_config"
            fi
        else
            echo "$line" >> "$temp_config"
        fi
    done < "$config_file"
    
    source "$temp_config"
    local result=$?
    rm -f "$temp_config"
    return $result
}

safe_load_remote_config "$CONFIG_FILE"

# 识别本机在任务配置中的IP（避免将自身误认为远端）
determine_self_ip() {
    local_ips=$(ip -o -4 addr show 2>/dev/null | awk '{print $4}' | cut -d/ -f1)
    [ -z "$local_ips" ] && local_ips=$(hostname -I 2>/dev/null)
    local self=""
    for ((j=1; j<=$SERVER_COUNT; j++)); do
        si="SERVER_$j"
        sd="${!si}"
        sip=$(echo "$sd" | cut -d: -f1)
        for lip in $local_ips; do
            if [ "$sip" = "$lip" ]; then
                self="$sip"
                break 2
            fi
        done
    done
    if [ -z "$self" ]; then
        self=$(hostname -I | awk '{print $1}')
    fi
    echo "$self"
}

SELF_IP=$(determine_self_ip)

echo "[$(date '+%Y-%m-%d %H:%M:%S')] 启动主主同步服务，当前服务器外网IP: $(curl -s ipinfo.io/ip)" >> /var/log/sync_tool/sync.log

# 配置SSH密钥
setup_ssh_keys() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] 配置SSH密钥..." >> /var/log/sync_tool/sync.log

    # 生成SSH密钥对
    if [ ! -f "/root/.ssh/id_rsa" ]; then
        ssh-keygen -t rsa -N "" -f /root/.ssh/id_rsa
        echo "[$(date '+%Y-%m-%d %H:%M:%S')] SSH密钥已生成" >> /var/log/sync_tool/sync.log
    fi

    # 复制公钥到所有服务器（使用 sshpass + ssh-copy-id）
    for ((i=1; i<=$SERVER_COUNT; i++)); do
        server_info="SERVER_$i"
        server_data="${!server_info}"
        server_ip=$(echo "$server_data" | cut -d: -f1)
        ssh_port=$(echo "$server_data" | cut -d: -f2)
        ssh_user=$(echo "$server_data" | cut -d: -f3)
        # 提取密码部分（可能包含加密数据中的冒号）
        encrypted_password=$(echo "$server_data" | sed 's/^[^:]*:[^:]*:[^:]*://')
        ssh_password=$(decrypt_remote_data "$encrypted_password")

        if [ "$server_ip" != "$SELF_IP" ]; then
            echo "[$(date '+%Y-%m-%d %H:%M:%S')] 配置SSH密钥到 $server_ip..." >> /var/log/sync_tool/sync.log
            # 优先使用 ssh-copy-id；若不存在则走手动追加
            if command -v sshpass >/dev/null 2>&1 && command -v ssh-copy-id >/dev/null 2>&1; then
                sshpass -p "$ssh_password" ssh-copy-id -p "$ssh_port" -o StrictHostKeyChecking=no "$ssh_user@$server_ip" >> /var/log/sync_tool/sync.log 2>&1
            else
                pub_key=$(cat /root/.ssh/id_rsa.pub)
                sshpass -p "$ssh_password" ssh -p "$ssh_port" -o StrictHostKeyChecking=no "$ssh_user@$server_ip" "mkdir -p ~/.ssh && chmod 700 ~/.ssh && grep -qxF '$pub_key' ~/.ssh/authorized_keys 2>/dev/null || echo '$pub_key' >> ~/.ssh/authorized_keys && chmod 600 ~/.ssh/authorized_keys" >> /var/log/sync_tool/sync.log 2>&1
            fi

            echo "[$(date '+%Y-%m-%d %H:%M:%S')] SSH密钥配置到 $server_ip 完成" >> /var/log/sync_tool/sync.log
        fi
    done
}

# 执行SSH密钥配置
setup_ssh_keys

# 测试SSH连接
test_ssh_connections() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] 测试SSH连接..." >> /var/log/sync_tool/sync.log

    for ((i=1; i<=$SERVER_COUNT; i++)); do
        server_info="SERVER_$i"
        server_data="${!server_info}"
        server_ip=$(echo "$server_data" | cut -d: -f1)
        ssh_port=$(echo "$server_data" | cut -d: -f2)
        ssh_user=$(echo "$server_data" | cut -d: -f3)

        if [ "$server_ip" != "$SELF_IP" ]; then
            if ssh -p "$ssh_port" -o ConnectTimeout=10 -o StrictHostKeyChecking=no "$ssh_user@$server_ip" "echo 'SSH连接测试成功'" >> /var/log/sync_tool/sync.log 2>&1; then
                echo "[$(date '+%Y-%m-%d %H:%M:%S')] SSH连接到 $server_ip 成功" >> /var/log/sync_tool/sync.log
            else
                echo "[$(date '+%Y-%m-%d %H:%M:%S')] SSH连接到 $server_ip 失败" >> /var/log/sync_tool/sync.log
            fi
        fi
    done
}

# 执行SSH连接测试
test_ssh_connections

# 同步函数
sync_to_server() {
    local dir="$1"
    local server_ip="$2"
    local ssh_port="$3"
    local ssh_user="$4"
    local max_retries=3
    local retry_count=0

    while [ $retry_count -lt $max_retries ]; do
        retry_count=$((retry_count + 1))
        echo "[$(date '+%Y-%m-%d %H:%M:%S')] 同步到 $server_ip (尝试 $retry_count/$max_retries)..." >> /var/log/sync_tool/sync.log

        # 确保目标服务器上的同步目录存在（避免新建目录时 rsync 失败）
        ssh -p "$ssh_port" -o ConnectTimeout=10 -o StrictHostKeyChecking=no -o PasswordAuthentication=no "$ssh_user@$server_ip" "[ -d \"$dir\" ] || mkdir -p \"$dir\"" >> /var/log/sync_tool/sync.log 2>&1 || true

        if rsync -avz --delete --timeout=30 -e "ssh -p $ssh_port -o ConnectTimeout=10 -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o PasswordAuthentication=no" "$dir/" "$ssh_user@$server_ip:$dir/" >> /var/log/sync_tool/sync.log 2>&1; then
            echo "[$(date '+%Y-%m-%d %H:%M:%S')] 同步到 $server_ip 成功" >> /var/log/sync_tool/sync.log
            return 0
        else
            echo "[$(date '+%Y-%m-%d %H:%M:%S')] 同步到 $server_ip 失败 (尝试 $retry_count/$max_retries)" >> /var/log/sync_tool/sync.log
            if [ $retry_count -lt $max_retries ]; then
                sleep 2
            fi
        fi
    done

    echo "[$(date '+%Y-%m-%d %H:%M:%S')] 同步到 $server_ip 最终失败" >> /var/log/sync_tool/sync.log
    return 1
}

# 启动文件监控
for dir in $SYNC_DIRS; do
    mkdir -p "$dir"
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] 开始监控目录: $dir" >> /var/log/sync_tool/sync.log

    inotifywait -m -r "$dir" -e modify,create,delete,move | while read path action file; do
        echo "[$(date '+%Y-%m-%d %H:%M:%S')] 检测到变化: $action $path$file" >> /var/log/sync_tool/sync.log

        # 同步到所有其他服务器
        for ((i=1; i<=$SERVER_COUNT; i++)); do
            server_info="SERVER_$i"
            server_data="${!server_info}"
            server_ip=$(echo "$server_data" | cut -d: -f1)
            ssh_port=$(echo "$server_data" | cut -d: -f2)
            ssh_user=$(echo "$server_data" | cut -d: -f3)

            if [ "$server_ip" != "$SELF_IP" ]; then
                sync_to_server "$dir" "$server_ip" "$ssh_port" "$ssh_user"
            fi
        done
    done &
done

wait
SCRIPT_EOF

    # 创建系统服务文件
    cat > /tmp/sync_tool.service << 'SERVICE_EOF'
[Unit]
Description=Master-Master File Sync Service
After=network.target

[Service]
Type=simple
ExecStart=/usr/local/bin/sync_master_master.sh
Restart=always
RestartSec=10
User=root

[Install]
WantedBy=multi-user.target
SERVICE_EOF


    # 使用 sshpass/ssh/scp 无交互部署（替换 expect，提升稳定性）
    local SSH_BASE="sshpass -p \"$password\" ssh -p $port -o StrictHostKeyChecking=no"
    local SCP_BASE="sshpass -p \"$password\" scp -P $port"

    # 远端准备：目录与依赖
    $SSH_BASE $user@$ip "mkdir -p /etc/sync_tool/tasks /var/log/sync_tool && \
        (command -v rsync >/dev/null 2>&1 && command -v inotifywait >/dev/null 2>&1 && command -v sshpass >/dev/null 2>&1 && command -v ssh-copy-id >/dev/null 2>&1 || \
        ( (command -v yum >/dev/null 2>&1 && yum install -y rsync inotify-tools sshpass openssh-clients >/dev/null 2>&1) || \
          (command -v apt-get >/dev/null 2>&1 && apt-get update >/dev/null 2>&1 && apt-get install -y rsync inotify-tools sshpass openssh-client >/dev/null 2>&1) ))"

    # 同步任务配置到当前服务器，确保服务启动有配置
    $SCP_BASE "$TASKS_DIR/$task_name.conf" $user@$ip:/etc/sync_tool/tasks/$task_name.conf >/dev/null 2>&1 || true

    # 上传脚本与服务文件
    $SCP_BASE /tmp/sync_master_master.sh $user@$ip:/usr/local/bin/sync_master_master.sh
    $SCP_BASE /tmp/sync_tool.service $user@$ip:/etc/systemd/system/sync_tool.service

    # 配置并启动服务
    $SSH_BASE $user@$ip "chmod +x /usr/local/bin/sync_master_master.sh && \
        sed -i 's|ExecStart=/usr/local/bin/sync_master_master.sh|ExecStart=/usr/local/bin/sync_master_master.sh $task_name|' /etc/systemd/system/sync_tool.service && \
        systemctl daemon-reload && systemctl enable sync_tool >/dev/null 2>&1 || true && \
        (systemctl restart sync_tool || systemctl start sync_tool)"

    # 清理临时文件
    rm -f /tmp/sync_master_master.sh /tmp/sync_tool.service

    echo -e "${GREEN}✅ 服务器 $ip 主主同步部署完成${NC}"
}

deploy_master_server() {
    local task_name="$1"
    local config_file="$TASKS_DIR/$task_name.conf"

    if [ ! -f "$config_file" ]; then
        echo -e "${RED}❌ 任务配置文件不存在${NC}"
        return
    fi

    safe_load_config "$config_file"
    echo -e "${CYAN}部署主机服务器: $MASTER_IP${NC}"

    # 生成主机端同步脚本
    cat > /tmp/sync_master.sh << 'MASTER_SCRIPT'
#!/bin/bash
# 主机同步脚本

TASK_NAME="$1"
CONFIG_FILE="/etc/sync_tool/tasks/$TASK_NAME.conf"

if [ ! -f "$CONFIG_FILE" ]; then
    echo "配置文件不存在: $CONFIG_FILE"
    exit 1
fi

# 解密函数
decrypt_remote_data() {
    local encrypted_data="$1"
    local key_file="/etc/sync_tool/.encryption_key"
    
    if [ -z "$encrypted_data" ]; then
        return 1
    fi
    
    # 检查是否为加密数据
    if [[ "$encrypted_data" =~ ^ENC: ]]; then
        local data=$(echo "$encrypted_data" | sed 's/^ENC://')
        
        # 尝试生成密钥
        if [ ! -f "$key_file" ]; then
            local system_info=""
            if [ -f "/proc/cpuinfo" ]; then
                system_info+=$(grep -m1 "model name" /proc/cpuinfo 2>/dev/null | cut -d: -f2 | tr -d ' ' || echo "")
            fi
            system_info+=$(hostname 2>/dev/null || echo "")
            system_info+=$(ip link show 2>/dev/null | grep -o -E '([0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}' | head -1 || echo "")
            
            if [ -z "$system_info" ]; then
                system_info="sync_tool_fallback_key_$(date +%s)_$(whoami)"
            fi
            
            local key=$(echo -n "$system_info" | sha256sum | cut -d' ' -f1)
            echo "$key" > "$key_file"
            chmod 600 "$key_file"
        fi
        
        local key=$(cat "$key_file")
        local iv=$(echo "$data" | cut -d: -f1)
        local encrypted=$(echo "$data" | cut -d: -f2-)
        local decrypted=$(echo "$encrypted" | openssl enc -aes-256-cbc -a -A -d -K "$key" -iv "$iv" 2>/dev/null)
        
        if [ $? -eq 0 ]; then
            echo "$decrypted"
        else
            return 1
        fi
    else
        echo "$encrypted_data"
    fi
}

# 安全加载配置文件
safe_load_remote_config() {
    local config_file="$1"
    
    if [ ! -f "$config_file" ]; then
        echo "配置文件不存在: $config_file" >&2
        return 1
    fi
    
    # 创建临时配置文件
    local temp_config=$(mktemp)
    
    # 读取原配置文件并处理加密数据
    while IFS= read -r line; do
        # 跳过注释和空行
        if [[ "$line" =~ ^[[:space:]]*# ]] || [[ -z "$line" ]]; then
            echo "$line" >> "$temp_config"
            continue
        fi
        
        # 检查是否包含敏感信息（密码字段）
        if [[ "$line" =~ ^(SERVER_[0-9]+|MASTER_SSH_PASSWORD|SLAVE_[0-9]+)= ]]; then
            # 提取变量名和值
            local var_name=$(echo "$line" | cut -d'=' -f1)
            local var_value=$(echo "$line" | cut -d'=' -f2- | sed 's/^"//;s/"$//')
            
            # 检查是否为加密数据
            if [[ "$var_value" =~ ^ENC: ]]; then
                # 解密数据
                local decrypted_value=$(decrypt_remote_data "$var_value")
                if [ $? -eq 0 ]; then
                    echo "${var_name}=\"$decrypted_value\"" >> "$temp_config"
                else
                    echo "$line" >> "$temp_config"
                fi
            else
                # 非加密数据，直接保存
                echo "$line" >> "$temp_config"
            fi
        else
            # 非敏感信息，直接保存
            echo "$line" >> "$temp_config"
        fi
    done < "$config_file"
    
    # 加载临时配置文件
    source "$temp_config"
    rm -f "$temp_config"
}

safe_load_remote_config "$CONFIG_FILE"

for dir in $SYNC_DIRS; do
    inotifywait -m -r "$dir" -e modify,create,delete,move | while read path action file; do
        echo "[$(date '+%Y-%m-%d %H:%M:%S')] 检测到变化: $action $path$file" >> /var/log/sync_tool/sync.log
        for ((i=1; i<=$SLAVE_COUNT; i++)); do
            slave_info="SLAVE_$i"
            slave_data="${!slave_info}"
            slave_ip=$(echo "$slave_data" | cut -d: -f1)
            ssh_port=$(echo "$slave_data" | cut -d: -f2)
            ssh_user=$(echo "$slave_data" | cut -d: -f3)
            ssh -p "$ssh_port" -o ConnectTimeout=10 -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o PasswordAuthentication=no "$ssh_user@$slave_ip" "[ -d \"$dir\" ] || mkdir -p \"$dir\"" >> /var/log/sync_tool/sync.log 2>&1 || true
            rsync -avz --delete --timeout=30 -e "ssh -p $ssh_port -o ConnectTimeout=10 -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o PasswordAuthentication=no" "$dir/" "$ssh_user@$slave_ip:$dir/" >> /var/log/sync_tool/sync.log 2>&1
        done
    done &
done

wait
MASTER_SCRIPT

    # 生成服务文件
    cat > /tmp/sync_tool.service << 'SERVICE'
[Unit]
Description=Master (Push) File Sync Service
After=network.target

[Service]
Type=simple
ExecStart=/usr/local/bin/sync_master.sh
Restart=always
User=root

[Install]
WantedBy=multi-user.target
SERVICE

    # 远端安装与下发
    local master_password=$(decrypt_sensitive_info "$MASTER_SSH_PASSWORD")
    local SSH_BASE="sshpass -p \"$master_password\" ssh -p $MASTER_SSH_PORT -o StrictHostKeyChecking=no"
    local SCP_BASE="sshpass -p \"$master_password\" scp -P $MASTER_SSH_PORT"
    $SSH_BASE "$MASTER_SSH_USER@$MASTER_IP" "mkdir -p /etc/sync_tool/tasks /var/log/sync_tool && (command -v rsync >/dev/null 2>&1 && command -v inotifywait >/dev/null 2>&1 || ((command -v yum >/dev/null 2>&1 && yum install -y rsync inotify-tools >/dev/null 2>&1) || (command -v apt-get >/dev/null 2>&1 && apt-get update >/dev/null 2>&1 && apt-get install -y rsync inotify-tools >/dev/null 2>&1)))"
    $SCP_BASE /tmp/sync_master.sh "$MASTER_SSH_USER@$MASTER_IP:/usr/local/bin/sync_master.sh"
    $SCP_BASE /tmp/sync_tool.service "$MASTER_SSH_USER@$MASTER_IP:/etc/systemd/system/sync_tool.service"
    $SCP_BASE "$TASKS_DIR/$task_name.conf" "$MASTER_SSH_USER@$MASTER_IP:/etc/sync_tool/tasks/$task_name.conf" >/dev/null 2>&1 || true
    $SSH_BASE "$MASTER_SSH_USER@$MASTER_IP" "chmod +x /usr/local/bin/sync_master.sh && sed -i 's|ExecStart=/usr/local/bin/sync_master.sh|ExecStart=/usr/local/bin/sync_master.sh $task_name|' /etc/systemd/system/sync_tool.service && systemctl daemon-reload && systemctl enable sync_tool >/dev/null 2>&1 || true && (systemctl restart sync_tool || systemctl start sync_tool)"

    rm -f /tmp/sync_master.sh /tmp/sync_tool.service
    echo -e "${GREEN}✅ 主机服务器部署完成${NC}"
}

deploy_slave_server() {
    local ip="$1"
    local port="$2"
    local user="$3"
    local password="$4"
    local task_name="$5"

    echo -e "${CYAN}部署从机服务器 $ip${NC}"

    # 生成从机监控脚本
    cat > /tmp/sync_slave.sh << 'SLAVE_SCRIPT'
#!/bin/bash
# 从机监控脚本

TASK_NAME="$1"
CONFIG_FILE="/etc/sync_tool/tasks/$TASK_NAME.conf"

if [ ! -f "$CONFIG_FILE" ]; then
    echo "配置文件不存在: $CONFIG_FILE"
    exit 1
fi

# 解密函数
decrypt_remote_data() {
    local encrypted_data="$1"
    local key_file="/etc/sync_tool/.encryption_key"
    
    if [ -z "$encrypted_data" ]; then
        return 1
    fi
    
    # 检查是否为加密数据
    if [[ "$encrypted_data" =~ ^ENC: ]]; then
        local data=$(echo "$encrypted_data" | sed 's/^ENC://')
        
        # 尝试生成密钥
        if [ ! -f "$key_file" ]; then
            local system_info=""
            if [ -f "/proc/cpuinfo" ]; then
                system_info+=$(grep -m1 "model name" /proc/cpuinfo 2>/dev/null | cut -d: -f2 | tr -d ' ' || echo "")
            fi
            system_info+=$(hostname 2>/dev/null || echo "")
            system_info+=$(ip link show 2>/dev/null | grep -o -E '([0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}' | head -1 || echo "")
            
            if [ -z "$system_info" ]; then
                system_info="sync_tool_fallback_key_$(date +%s)_$(whoami)"
            fi
            
            local key=$(echo -n "$system_info" | sha256sum | cut -d' ' -f1)
            echo "$key" > "$key_file"
            chmod 600 "$key_file"
        fi
        
        local key=$(cat "$key_file")
        local iv=$(echo "$data" | cut -d: -f1)
        local encrypted=$(echo "$data" | cut -d: -f2-)
        local decrypted=$(echo "$encrypted" | openssl enc -aes-256-cbc -a -A -d -K "$key" -iv "$iv" 2>/dev/null)
        
        if [ $? -eq 0 ]; then
            echo "$decrypted"
        else
            return 1
        fi
    else
        echo "$encrypted_data"
    fi
}

# 安全加载配置文件
safe_load_remote_config() {
    local config_file="$1"
    
    if [ ! -f "$config_file" ]; then
        echo "配置文件不存在: $config_file" >&2
        return 1
    fi
    
    # 创建临时配置文件
    local temp_config=$(mktemp)
    
    # 读取原配置文件并处理加密数据
    while IFS= read -r line; do
        # 跳过注释和空行
        if [[ "$line" =~ ^[[:space:]]*# ]] || [[ -z "$line" ]]; then
            echo "$line" >> "$temp_config"
            continue
        fi
        
        # 检查是否包含敏感信息（密码字段）
        if [[ "$line" =~ ^(SERVER_[0-9]+|MASTER_SSH_PASSWORD|SLAVE_[0-9]+)= ]]; then
            # 提取变量名和值
            local var_name=$(echo "$line" | cut -d'=' -f1)
            local var_value=$(echo "$line" | cut -d'=' -f2- | sed 's/^"//;s/"$//')
            
            # 检查是否为加密数据
            if [[ "$var_value" =~ ^ENC: ]]; then
                # 解密数据
                local decrypted_value=$(decrypt_remote_data "$var_value")
                if [ $? -eq 0 ]; then
                    echo "${var_name}=\"$decrypted_value\"" >> "$temp_config"
                else
                    echo "$line" >> "$temp_config"
                    fi
            else
                # 非加密数据，直接保存
                echo "$line" >> "$temp_config"
            fi
        else
            # 非敏感信息，直接保存
            echo "$line" >> "$temp_config"
        fi
    done < "$config_file"
    
    # 加载临时配置文件
    source "$temp_config"
    rm -f "$temp_config"
}

safe_load_remote_config "$CONFIG_FILE"

for dir in $SYNC_DIRS; do
    mkdir -p "$dir"
done

for dir in $SYNC_DIRS; do
    inotifywait -m -r "$dir" -e delete,delete_self,moved_from | while read path action file; do
        echo "[$(date '+%Y-%m-%d %H:%M:%S')] 检测到删除: $action $path$file" >> /var/log/sync_tool/recovery.log
        ssh_port="$MASTER_SSH_PORT"
        ssh_user="$MASTER_SSH_USER"
        relative_path="${path#$dir/}"
        if ssh -p "$ssh_port" -o StrictHostKeyChecking=no -o PasswordAuthentication=no "$ssh_user@$MASTER_IP" "test -f '$dir/$relative_path$file'" 2>/dev/null; then
            scp -P "$ssh_port" -o StrictHostKeyChecking=no -o PasswordAuthentication=no "$ssh_user@$MASTER_IP:$dir/$relative_path$file" "$path$file" >> /var/log/sync_tool/recovery.log 2>&1
        fi
    done &
done

wait
SLAVE_SCRIPT

    # 生成服务文件
    cat > /tmp/sync_tool.service << 'SERVICE'
[Unit]
Description=Slave (Recover) File Sync Service
After=network.target

[Service]
Type=simple
ExecStart=/usr/local/bin/sync_slave.sh
Restart=always
User=root

[Install]
WantedBy=multi-user.target
SERVICE

    # 远端安装与下发
    local SSH_BASE="sshpass -p \"$password\" ssh -p $port -o StrictHostKeyChecking=no"
    local SCP_BASE="sshpass -p \"$password\" scp -P $port"
    $SSH_BASE $user@$ip "mkdir -p /etc/sync_tool/tasks /var/log/sync_tool && (command -v inotifywait >/dev/null 2>&1 || ((command -v yum >/dev/null 2>&1 && yum install -y inotify-tools >/dev/null 2>&1) || (command -v apt-get >/dev/null 2>&1 && apt-get update >/dev/null 2>&1 && apt-get install -y inotify-tools >/dev/null 2>&1)))"
    $SCP_BASE /tmp/sync_slave.sh $user@$ip:/usr/local/bin/sync_slave.sh
    $SCP_BASE /tmp/sync_tool.service $user@$ip:/etc/systemd/system/sync_tool.service
    $SCP_BASE "$TASKS_DIR/$task_name.conf" $user@$ip:/etc/sync_tool/tasks/$task_name.conf >/dev/null 2>&1 || true
    $SSH_BASE $user@$ip "chmod +x /usr/local/bin/sync_slave.sh && sed -i 's|ExecStart=/usr/local/bin/sync_slave.sh|ExecStart=/usr/local/bin/sync_slave.sh $task_name|' /etc/systemd/system/sync_tool.service && systemctl daemon-reload && systemctl enable sync_tool >/dev/null 2>&1 || true && (systemctl restart sync_tool || systemctl start sync_tool)"

    rm -f /tmp/sync_slave.sh /tmp/sync_tool.service
    echo -e "${GREEN}✅ 从机服务器 $ip 部署完成${NC}"
}

# 任务管理函数
start_sync_service() {
    echo -e "${GREEN}启动同步任务服务...${NC}"
    systemctl start sync_tool
    echo -e "${GREEN}✅ 同步任务服务已启动${NC}"
}

stop_sync_service() {
    echo -e "${YELLOW}停止同步任务服务...${NC}"
    systemctl stop sync_tool
    echo -e "${GREEN}✅ 同步任务服务已停止${NC}"
}

restart_sync_service() {
    echo -e "${YELLOW}重启同步任务服务...${NC}"
    systemctl restart sync_tool
    echo -e "${GREEN}✅ 同步任务服务已重启${NC}"
}

add_new_task() {
    echo -e "${CYAN}添加新的同步任务...${NC}"
    # 这里可以调用主主模式或主从模式配置函数
    echo -e "${YELLOW}请返回主菜单选择模式${NC}"
}

list_all_tasks() {
    echo -e "\n${CYAN}所有任务列表：${NC}"
    if [ -d "$TASKS_DIR" ] && [ "$(ls -A "$TASKS_DIR")" ]; then
        for config_file in "$TASKS_DIR"/*.conf; do
            if [ -f "$config_file" ]; then
                safe_load_config "$config_file"
                echo -e "${WHITE}任务: $TASK_NAME${NC}"
                echo -e "${CYAN}  模式: $SYNC_MODE${NC}"
                echo -e "${CYAN}  创建时间: $CREATED_TIME${NC}"
                echo -e "${CYAN}  同步目录: $SYNC_DIRS${NC}"
                echo
            fi
        done
    else
        echo -e "${YELLOW}暂无任务${NC}"
    fi
}

test_sync_task() {
    echo -e "${CYAN}运行测试同步任务...${NC}"

    # 列出所有任务
    echo -e "\n${WHITE}可用任务：${NC}"
    task_list=()
    i=1
    for config_file in "$TASKS_DIR"/*.conf; do
        if [ -f "$config_file" ]; then
            safe_load_config "$config_file"
            echo -e "${CYAN}$i.${NC} ${WHITE}$TASK_NAME${NC} (${CYAN}$SYNC_MODE${NC})"
            task_list+=("$config_file")
            ((i++))
        fi
    done

    if [ ${#task_list[@]} -eq 0 ]; then
        echo -e "${YELLOW}暂无任务${NC}"
        return
    fi

    read -p "请选择任务编号: " task_num
    if [[ "$task_num" =~ ^[0-9]+$ ]] && [ "$task_num" -ge 1 ] && [ "$task_num" -le ${#task_list[@]} ]; then
        selected_task="${task_list[$((task_num-1))]}"
        safe_load_config "$selected_task"

        echo -e "\n${GREEN}开始测试任务: $TASK_NAME${NC}"

        if [ "$SYNC_MODE" = "master_master" ]; then
            test_master_master_sync "$selected_task"
        elif [ "$SYNC_MODE" = "master_slave" ]; then
            test_master_slave_sync "$selected_task"
        fi
    else
        echo -e "${RED}❌ 无效选择${NC}"
    fi
}

# 测试主主同步
test_master_master_sync() {
    local config_file="$1"
    safe_load_config "$config_file"

    echo -e "\n${YELLOW}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
    echo -e "${WHITE}🧪 主主同步测试${NC}"
    echo -e "${YELLOW}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"

    # 选择测试服务器
    echo -e "\n${CYAN}选择测试服务器：${NC}"
    for ((i=1; i<=$SERVER_COUNT; i++)); do
        local server_info="SERVER_$i"
        local server_data="${!server_info}"
        local server_ip=$(echo "$server_data" | cut -d: -f1)
        echo -e "${CYAN}$i.${NC} ${WHITE}$server_ip${NC}"
    done

    read -p "请选择测试服务器编号: " test_server_num
    if ! [[ "$test_server_num" =~ ^[0-9]+$ ]] || [ "$test_server_num" -lt 1 ] || [ "$test_server_num" -gt $SERVER_COUNT ]; then
        echo -e "${RED}❌ 无效选择${NC}"
        return
    fi

    local server_info="SERVER_$test_server_num"
    local server_data="${!server_info}"
    local server_ip=$(echo "$server_data" | cut -d: -f1)
    local ssh_port=$(echo "$server_data" | cut -d: -f2)
    local ssh_user=$(echo "$server_data" | cut -d: -f3)

    echo -e "\n${CYAN}在服务器 $server_ip 上创建测试文件...${NC}"

    # 创建测试文件
    local test_dir=$(echo "$SYNC_DIRS" | awk '{print $1}')
    local test_file="$test_dir/test_sync_$(date +%s).txt"

    # 通过SSH创建测试文件
    ssh -p "$ssh_port" -o StrictHostKeyChecking=no "$ssh_user@$server_ip" "[ -d $test_dir ] || mkdir -p $test_dir; echo '测试同步文件 - $(date)' > $test_file"

    if [ $? -eq 0 ]; then
        echo -e "${GREEN}✅ 测试文件创建成功: $test_file${NC}"
        echo -e "${CYAN}等待5秒让同步完成...${NC}"
        sleep 5

        # 检查其他服务器是否同步了文件
        echo -e "\n${CYAN}检查其他服务器的同步状态：${NC}"
        for ((i=1; i<=$SERVER_COUNT; i++)); do
            if [ $i -ne $test_server_num ]; then
                local other_server_info="SERVER_$i"
                local other_server_data="${!other_server_info}"
                local other_server_ip=$(echo "$other_server_data" | cut -d: -f1)
                local other_ssh_port=$(echo "$other_server_data" | cut -d: -f2)
                local other_ssh_user=$(echo "$other_server_data" | cut -d: -f3)

                if ssh -p "$other_ssh_port" -o StrictHostKeyChecking=no "$other_ssh_user@$other_server_ip" "test -f $test_file" 2>/dev/null; then
                    echo -e "${GREEN}✅ $other_server_ip: 文件已同步${NC}"
                else
                    echo -e "${RED}❌ $other_server_ip: 文件未同步${NC}"
                fi
            fi
        done

        # 清理测试文件
        echo -e "\n${CYAN}清理测试文件...${NC}"
        for ((i=1; i<=$SERVER_COUNT; i++)); do
            local server_info="SERVER_$i"
            local server_data="${!server_info}"
            local server_ip=$(echo "$server_data" | cut -d: -f1)
            local ssh_port=$(echo "$server_data" | cut -d: -f2)
            local ssh_user=$(echo "$server_data" | cut -d: -f3)

            ssh -p "$ssh_port" -o StrictHostKeyChecking=no "$ssh_user@$server_ip" "rm -f $test_file" 2>/dev/null
        done

        echo -e "${GREEN}✅ 测试完成${NC}"
    else
        echo -e "${RED}❌ 测试文件创建失败${NC}"
    fi
}

# 测试主从同步
test_master_slave_sync() {
    local config_file="$1"
    safe_load_config "$config_file"

    echo -e "\n${YELLOW}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
    echo -e "${WHITE}🧪 主从同步测试${NC}"
    echo -e "${YELLOW}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"

    echo -e "\n${CYAN}在主机 $MASTER_IP 上创建测试文件...${NC}"

    # 创建测试文件
    local test_dir=$(echo "$SYNC_DIRS" | awk '{print $1}')
    local test_file="$test_dir/test_sync_$(date +%s).txt"

    # 通过SSH创建测试文件
    ssh -p "$MASTER_SSH_PORT" -o StrictHostKeyChecking=no "$MASTER_SSH_USER@$MASTER_IP" "[ -d $test_dir ] || mkdir -p $test_dir; echo '测试同步文件 - $(date)' > $test_file"

    if [ $? -eq 0 ]; then
        echo -e "${GREEN}✅ 测试文件创建成功: $test_file${NC}"
        echo -e "${CYAN}等待5秒让同步完成...${NC}"
        sleep 5

        # 检查从机是否同步了文件
        echo -e "\n${CYAN}检查从机的同步状态：${NC}"
        for ((i=1; i<=$SLAVE_COUNT; i++)); do
            local slave_info="SLAVE_$i"
            local slave_data="${!slave_info}"
            local slave_ip=$(echo "$slave_data" | cut -d: -f1)
            local ssh_port=$(echo "$slave_data" | cut -d: -f2)
            local ssh_user=$(echo "$slave_data" | cut -d: -f3)

            if ssh -p "$ssh_port" -o StrictHostKeyChecking=no "$ssh_user@$slave_ip" "test -f $test_file" 2>/dev/null; then
                echo -e "${GREEN}✅ $slave_ip: 文件已同步${NC}"
            else
                echo -e "${RED}❌ $slave_ip: 文件未同步${NC}"
            fi
        done

        # 清理测试文件
        echo -e "\n${CYAN}清理测试文件...${NC}"
        ssh -p "$MASTER_SSH_PORT" -o StrictHostKeyChecking=no "$MASTER_SSH_USER@$MASTER_IP" "rm -f $test_file" 2>/dev/null

        echo -e "${GREEN}✅ 测试完成${NC}"
    else
        echo -e "${RED}❌ 测试文件创建失败${NC}"
    fi
}

view_service_logs() {
    while true; do
        clear
        echo -e "${YELLOW}==== 同步任务日志 ====${NC}"
        echo -e "${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
        echo -e "${WHITE}请选择日志查看方式：${NC}"
        echo -e "${CYAN}1.${NC} 最近50行 同步日志"
        echo -e "${CYAN}2.${NC} 实时跟随 同步日志 (tail -n 50 -f)"
        echo -e "${CYAN}3.${NC} 最近50行 恢复日志"
        echo -e "${CYAN}4.${NC} 实时跟随 恢复日志 (tail -n 50 -f)"
        echo -e "${CYAN}5.${NC} systemd 服务日志 (最近100行)"
        echo -e "${CYAN}0.${NC} 返回"
        echo -e "${GREEN}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
        read -p "请选择 [0-5]: " log_choice

        case "$log_choice" in
            1)
                if [ -f "$LOG_DIR/sync.log" ]; then
                    tail -n 50 "$LOG_DIR/sync.log" | sed -e 's/^/  /'
                elif [ -f "$LOG_DIR/sync_tool.log" ]; then
                    tail -n 50 "$LOG_DIR/sync_tool.log" | sed -e 's/^/  /'
                else
                    echo -e "${YELLOW}暂无同步日志文件${NC}"
                fi
                read -p "\n按回车返回..." _
                ;;
            2)
                if [ -f "$LOG_DIR/sync.log" ]; then
                    tail -n 50 -f "$LOG_DIR/sync.log"
                elif [ -f "$LOG_DIR/sync_tool.log" ]; then
                    tail -n 50 -f "$LOG_DIR/sync_tool.log"
                else
                    echo -e "${YELLOW}暂无同步日志文件${NC}"
                    read -p "\n按回车返回..." _
                fi
                ;;
            3)
                if [ -f "$LOG_DIR/recovery.log" ]; then
                    tail -n 50 "$LOG_DIR/recovery.log" | sed -e 's/^/  /'
                else
                    echo -e "${YELLOW}暂无恢复日志文件${NC}"
                fi
                read -p "\n按回车返回..." _
                ;;
            4)
                if [ -f "$LOG_DIR/recovery.log" ]; then
                    tail -n 50 -f "$LOG_DIR/recovery.log"
                else
                    echo -e "${YELLOW}暂无恢复日志文件${NC}"
                    read -p "\n按回车返回..." _
                fi
                ;;
            5)
                journalctl -u sync_tool -n 100 --no-pager | sed -e 's/^/  /'
                read -p "\n按回车返回..." _
                ;;
            0)
                return
                ;;
            *)
                echo -e "${RED}❌ 无效选择${NC}"
                read -p "\n按回车返回..." _
                ;;
        esac
    done
}

start_specific_task() {
    echo -e "${CYAN}启动某个同步任务...${NC}"

    # 列出所有任务
    echo -e "\n${WHITE}可用任务：${NC}"
    task_list=()
    i=1
    for config_file in "$TASKS_DIR"/*.conf; do
        if [ -f "$config_file" ]; then
            safe_load_config "$config_file"
            echo -e "${CYAN}$i.${NC} ${WHITE}$TASK_NAME${NC} (${CYAN}$SYNC_MODE${NC})"
            task_list+=("$config_file")
            ((i++))
        fi
    done

    if [ ${#task_list[@]} -eq 0 ]; then
        echo -e "${YELLOW}暂无任务${NC}"
        return
    fi

    read -p "请选择任务编号: " task_num
    if [[ "$task_num" =~ ^[0-9]+$ ]] && [ "$task_num" -ge 1 ] && [ "$task_num" -le ${#task_list[@]} ]; then
        selected_task="${task_list[$((task_num-1))]}"
        safe_load_config "$selected_task"

        echo -e "${GREEN}启动任务: $TASK_NAME${NC}"
        systemctl start sync_tool
        echo -e "${GREEN}✅ 任务已启动${NC}"
    else
        echo -e "${RED}❌ 无效选择${NC}"
    fi
}

stop_specific_task() {
    echo -e "${CYAN}关停某个同步任务...${NC}"

    # 列出所有任务
    echo -e "\n${WHITE}可用任务：${NC}"
    task_list=()
    i=1
    for config_file in "$TASKS_DIR"/*.conf; do
        if [ -f "$config_file" ]; then
            safe_load_config "$config_file"
            echo -e "${CYAN}$i.${NC} ${WHITE}$TASK_NAME${NC} (${CYAN}$SYNC_MODE${NC})"
            task_list+=("$config_file")
            ((i++))
        fi
    done

    if [ ${#task_list[@]} -eq 0 ]; then
        echo -e "${YELLOW}暂无任务${NC}"
        return
    fi

    read -p "请选择任务编号: " task_num
    if [[ "$task_num" =~ ^[0-9]+$ ]] && [ "$task_num" -ge 1 ] && [ "$task_num" -le ${#task_list[@]} ]; then
        selected_task="${task_list[$((task_num-1))]}"
        safe_load_config "$selected_task"

        echo -e "${YELLOW}关停任务: $TASK_NAME${NC}"
        systemctl stop sync_tool
        echo -e "${GREEN}✅ 任务已关停${NC}"
    else
        echo -e "${RED}❌ 无效选择${NC}"
    fi
}

# 手动执行同步
manual_sync() {
    echo -e "${YELLOW}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
    echo -e "${WHITE}📋 手动执行同步${NC}"
    echo -e "${YELLOW}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"

    # 列出所有任务
    if [ ! -d "/etc/sync_tool/tasks" ]; then
        echo -e "${RED}❌ 没有找到同步任务配置目录${NC}"
        return
    fi

    tasks=($(ls /etc/sync_tool/tasks/*.conf 2>/dev/null))
    if [ ${#tasks[@]} -eq 0 ]; then
        echo -e "${RED}❌ 没有找到同步任务${NC}"
        return
    fi

    echo -e "${WHITE}可用的同步任务：${NC}"
    for i in "${!tasks[@]}"; do
        task_name=$(basename "${tasks[$i]}" .conf)
        echo -e "${CYAN}$((i+1)).${NC} ${WHITE}$task_name${NC}"
    done

    read -p "请选择任务编号 [1-${#tasks[@]}]: " task_choice

    if ! [[ "$task_choice" =~ ^[0-9]+$ ]] || [ "$task_choice" -lt 1 ] || [ "$task_choice" -gt ${#tasks[@]} ]; then
        echo -e "${RED}❌ 无效的选择${NC}"
        return
    fi

    selected_task="${tasks[$((task_choice-1))]}"
    task_name=$(basename "$selected_task" .conf)

    echo -e "${YELLOW}正在执行手动同步任务: $task_name${NC}"

    # 加载配置
    source "$selected_task"

    # 检查任务类型
    if [[ "$task_name" == master_master_* ]]; then
        manual_master_master_sync "$task_name"
    elif [[ "$task_name" == master_slave_* ]]; then
        manual_master_slave_sync "$task_name"
    else
        echo -e "${RED}❌ 未知的任务类型${NC}"
    fi
}

# 手动执行主主同步
manual_master_master_sync() {
    local task_name="$1"
    local config_file="/etc/sync_tool/tasks/$task_name.conf"

    if [ ! -f "$config_file" ]; then
        echo -e "${RED}❌ 配置文件不存在: $config_file${NC}"
        return
    fi

    safe_load_config "$config_file"
    CURRENT_IP=$(hostname -I | awk '{print $1}')

    echo -e "${YELLOW}开始手动主主同步...${NC}"
    echo -e "${WHITE}当前服务器外网IP: $(curl -s ipinfo.io/ip)${NC}"
    echo -e "${WHITE}同步目录: $SYNC_DIRS${NC}"

    # 配置SSH密钥
    echo -e "${YELLOW}配置SSH密钥...${NC}"
    if [ ! -f "/root/.ssh/id_rsa" ]; then
        ssh-keygen -t rsa -N "" -f /root/.ssh/id_rsa
        echo -e "${GREEN}✅ SSH密钥已生成${NC}"
    fi

    # 复制公钥到所有服务器
    for ((i=1; i<=$SERVER_COUNT; i++)); do
        server_info="SERVER_$i"
        server_data="${!server_info}"
        server_ip=$(echo "$server_data" | cut -d: -f1)
        ssh_port=$(echo "$server_data" | cut -d: -f2)
        ssh_user=$(echo "$server_data" | cut -d: -f3)
        # 提取密码部分（可能包含加密数据中的冒号）
        ssh_password=$(echo "$server_data" | sed 's/^[^:]*:[^:]*:[^:]*://')
        
        # 调试信息：检查密码是否已解密
        if [[ "$ssh_password" =~ ^ENC: ]]; then
            echo -e "${YELLOW}⚠️  密码仍为加密状态，尝试解密...${NC}"
            ssh_password=$(decrypt_sensitive_info "$ssh_password")
            if [ $? -ne 0 ]; then
                echo -e "${RED}❌ 密码解密失败${NC}"
                continue
            fi
        fi

        if [ "$server_ip" != "$CURRENT_IP" ]; then
            echo -e "${YELLOW}配置SSH密钥到 $server_ip...${NC}"

            # 使用expect复制公钥
            cat > /tmp/copy_key.exp << 'EXP_EOF'
#!/usr/bin/expect -f
set timeout 30
set ip [lindex $argv 0]
set port [lindex $argv 1]
set user [lindex $argv 2]
set password [lindex $argv 3]

spawn ssh-copy-id -p $port $user@$ip

expect {
    "yes/no" { send "yes\r"; exp_continue }
    "password:" { send "$password\r" }
}

expect eof
EXP_EOF

            expect /tmp/copy_key.exp "$server_ip" "$ssh_port" "$ssh_user" "$ssh_password" >/dev/null 2>&1
            rm -f /tmp/copy_key.exp

            echo -e "${GREEN}✅ SSH密钥配置到 $server_ip 完成${NC}"
        fi
    done

    # 执行同步
    for dir in $SYNC_DIRS; do
        echo -e "${YELLOW}同步目录: $dir${NC}"

        for ((i=1; i<=$SERVER_COUNT; i++)); do
            server_info="SERVER_$i"
            server_data="${!server_info}"
            server_ip=$(echo "$server_data" | cut -d: -f1)
            ssh_port=$(echo "$server_data" | cut -d: -f2)
            ssh_user=$(echo "$server_data" | cut -d: -f3)

            if [ "$server_ip" != "$CURRENT_IP" ]; then
                echo -e "${YELLOW}同步到 $server_ip...${NC}"

                # 确保目标目录存在
                ssh -p "$ssh_port" -o ConnectTimeout=10 -o StrictHostKeyChecking=no "$ssh_user@$server_ip" "[ -d $dir ] || mkdir -p $dir" 2>/dev/null

                # 执行同步
                if rsync -avz --delete --timeout=30 -e "ssh -p $ssh_port -o ConnectTimeout=10 -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o PasswordAuthentication=no" "$dir/" "$ssh_user@$server_ip:$dir/"; then
                    echo -e "${GREEN}✅ 同步到 $server_ip 成功${NC}"
                else
                    echo -e "${RED}❌ 同步到 $server_ip 失败${NC}"
                fi
            fi
        done
    done

    echo -e "${GREEN}✅ 手动主主同步完成${NC}"
}

# 手动执行主从同步
manual_master_slave_sync() {
    local task_name="$1"
    local config_file="/etc/sync_tool/tasks/$task_name.conf"

    if [ ! -f "$config_file" ]; then
        echo -e "${RED}❌ 配置文件不存在: $config_file${NC}"
        return
    fi

    safe_load_config "$config_file"

    echo -e "${YELLOW}开始手动主从同步...${NC}"
    echo -e "${WHITE}主服务器: $MASTER_IP${NC}"
    echo -e "${WHITE}从服务器: $SLAVE_IPS${NC}"
    echo -e "${WHITE}同步目录: $SYNC_DIRS${NC}"

    # 从主服务器同步到所有从服务器
    for slave_ip in $SLAVE_IPS; do
        echo -e "${YELLOW}同步到从服务器: $slave_ip${NC}"

        for dir in $SYNC_DIRS; do
            echo -e "${YELLOW}同步目录 $dir 到 $slave_ip...${NC}"

            # 确保目标目录存在
            ssh -p "$SLAVE_SSH_PORT" -o ConnectTimeout=10 -o StrictHostKeyChecking=no "$SLAVE_USER@$slave_ip" "[ -d $dir ] || mkdir -p $dir" 2>/dev/null

            # 执行同步
            if rsync -avz --delete --timeout=30 -e "ssh -p $SLAVE_SSH_PORT -o ConnectTimeout=10 -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o PasswordAuthentication=no" "$dir/" "$SLAVE_USER@$slave_ip:$dir/"; then
                echo -e "${GREEN}✅ 同步目录 $dir 到 $slave_ip 成功${NC}"
            else
                echo -e "${RED}❌ 同步目录 $dir 到 $slave_ip 失败${NC}"
            fi
        done
    done

    echo -e "${GREEN}✅ 手动主从同步完成${NC}"
}

# 测试SSH连接
test_ssh_connection() {
    echo -e "${YELLOW}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
    echo -e "${WHITE}🔍 测试SSH连接${NC}"
    echo -e "${YELLOW}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"

    # 列出所有任务
    if [ ! -d "/etc/sync_tool/tasks" ]; then
        echo -e "${RED}❌ 没有找到同步任务配置目录${NC}"
        return
    fi

    tasks=($(ls /etc/sync_tool/tasks/*.conf 2>/dev/null))
    if [ ${#tasks[@]} -eq 0 ]; then
        echo -e "${RED}❌ 没有找到同步任务${NC}"
        return
    fi

    echo -e "${WHITE}可用的同步任务：${NC}"
    for i in "${!tasks[@]}"; do
        task_name=$(basename "${tasks[$i]}" .conf)
        echo -e "${CYAN}$((i+1)).${NC} ${WHITE}$task_name${NC}"
    done

    read -p "请选择任务编号 [1-${#tasks[@]}]: " task_choice

    if ! [[ "$task_choice" =~ ^[0-9]+$ ]] || [ "$task_choice" -lt 1 ] || [ "$task_choice" -gt ${#tasks[@]} ]; then
        echo -e "${RED}❌ 无效的选择${NC}"
        return
    fi

    selected_task="${tasks[$((task_choice-1))]}"
    task_name=$(basename "$selected_task" .conf)

    echo -e "${YELLOW}正在测试SSH连接: $task_name${NC}"

    # 加载配置
    source "$selected_task"

    # 检查任务类型
    if [[ "$task_name" == master_master_* ]]; then
        test_master_master_ssh "$task_name"
    elif [[ "$task_name" == master_slave_* ]]; then
        test_master_slave_ssh "$task_name"
    else
        echo -e "${RED}❌ 未知的任务类型${NC}"
    fi
}

# 测试主主模式SSH连接
test_master_master_ssh() {
    local task_name="$1"
    local config_file="/etc/sync_tool/tasks/$task_name.conf"

    if [ ! -f "$config_file" ]; then
        echo -e "${RED}❌ 配置文件不存在: $config_file${NC}"
        return
    fi

    safe_load_config "$config_file"
    CURRENT_IP=$(hostname -I | awk '{print $1}')

    echo -e "${YELLOW}测试主主模式SSH连接...${NC}"
    echo -e "${WHITE}当前服务器外网IP: $(curl -s ipinfo.io/ip)${NC}"

    # 配置SSH密钥
    echo -e "${YELLOW}配置SSH密钥...${NC}"
    if [ ! -f "/root/.ssh/id_rsa" ]; then
        ssh-keygen -t rsa -N "" -f /root/.ssh/id_rsa
        echo -e "${GREEN}✅ SSH密钥已生成${NC}"
    fi

    # 测试每个服务器的SSH连接
    for ((i=1; i<=$SERVER_COUNT; i++)); do
        server_info="SERVER_$i"
        server_data="${!server_info}"
        server_ip=$(echo "$server_data" | cut -d: -f1)
        ssh_port=$(echo "$server_data" | cut -d: -f2)
        ssh_user=$(echo "$server_data" | cut -d: -f3)
        # 提取密码部分（可能包含加密数据中的冒号）
        ssh_password=$(echo "$server_data" | sed 's/^[^:]*:[^:]*:[^:]*://')
        
        # 解密密码（如果已加密）
        if [[ "$ssh_password" =~ ^ENC: ]]; then
            echo -e "${YELLOW}正在解密密文...${NC}"
            ssh_password=$(decrypt_sensitive_info "$ssh_password")
            if [ $? -ne 0 ]; then
                echo -e "${RED}❌ 密码解密失败${NC}"
                continue
            fi
        fi
        
        # 调试信息：显示密码长度（不显示实际密码）
        # echo -e "${CYAN}🔍 密码长度: ${#ssh_password} 字符${NC}"
        # echo -e "${CYAN}🔍 密码前缀: ${ssh_password:0:10}...${NC}"
        echo -e "${GREEN}✅ 密文解密成功${NC}"

        if [ "$server_ip" != "$CURRENT_IP" ]; then
            echo -e "${YELLOW}测试连接到 $server_ip:$ssh_port (用户: $ssh_user)...${NC}"

            # 先尝试密码连接（非交互，使用已解析的 ssh_password）
            if sshpass -p "$ssh_password" ssh -p "$ssh_port" \
                -o ConnectTimeout=10 -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null \
                -o PreferredAuthentications=password,keyboard-interactive -o PubkeyAuthentication=no \
                "$ssh_user@$server_ip" "echo 'SSH连接测试成功'" 2>/dev/null; then
                echo -e "${GREEN}✅ 密码SSH连接成功${NC}"

                # 复制公钥
                echo -e "${YELLOW}复制SSH公钥到 $server_ip...${NC}"
                cat > /tmp/copy_key.exp << 'EXP_EOF'
#!/usr/bin/expect -f
set timeout 30
set ip [lindex $argv 0]
set port [lindex $argv 1]
set user [lindex $argv 2]
set password [lindex $argv 3]

spawn ssh-copy-id -p $port $user@$ip

expect {
    "yes/no" { send "yes\r"; exp_continue }
    "password:" { send "$password\r" }
}

expect eof
EXP_EOF

                expect /tmp/copy_key.exp "$server_ip" "$ssh_port" "$ssh_user" "$ssh_password" >/dev/null 2>&1
                rm -f /tmp/copy_key.exp

                # 将对端公钥写入当前服务器（确保对端可免密连接当前服务器）
                remote_pub_key=$(sshpass -p "$ssh_password" ssh -p "$ssh_port" \
                    -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null \
                    "$ssh_user@$server_ip" "mkdir -p ~/.ssh && chmod 700 ~/.ssh && [ -f ~/.ssh/id_rsa ] || ssh-keygen -t rsa -N '' -f ~/.ssh/id_rsa >/dev/null 2>&1; cat ~/.ssh/id_rsa.pub" 2>/dev/null)
                if [ -n "$remote_pub_key" ]; then
                    mkdir -p ~/.ssh && chmod 700 ~/.ssh
                    grep -qxF "$remote_pub_key" ~/.ssh/authorized_keys 2>/dev/null || echo "$remote_pub_key" >> ~/.ssh/authorized_keys
                    chmod 600 ~/.ssh/authorized_keys 2>/dev/null || true
                fi

                # 测试密钥连接
                if ssh -p "$ssh_port" -o ConnectTimeout=10 -o StrictHostKeyChecking=no -o PasswordAuthentication=no "$ssh_user@$server_ip" "echo 'SSH密钥连接测试成功'" 2>/dev/null; then
                    echo -e "${GREEN}✅ SSH密钥连接成功${NC}"
                else
                    echo -e "${RED}❌ SSH密钥连接失败${NC}"
                fi
            else
                echo -e "${RED}❌ 密码SSH连接失败${NC}"
            fi
        fi
    done

    echo -e "${GREEN}✅ SSH连接测试完成${NC}"
}

# 测试主从模式SSH连接
test_master_slave_ssh() {
    local task_name="$1"
    local config_file="/etc/sync_tool/tasks/$task_name.conf"

    if [ ! -f "$config_file" ]; then
        echo -e "${RED}❌ 配置文件不存在: $config_file${NC}"
        return
    fi

    safe_load_config "$config_file"

    echo -e "${YELLOW}测试主从模式SSH连接...${NC}"
    echo -e "${WHITE}主服务器: $MASTER_IP${NC}"
    echo -e "${WHITE}从服务器: $SLAVE_IPS${NC}"

    # 测试从服务器连接（按配置逐台解析: ip:port:user:password）
    for ((i=1; i<=$SLAVE_COUNT; i++)); do
        local slave_info="SLAVE_$i"
        local slave_data="${!slave_info}"
        local slave_ip=$(echo "$slave_data" | cut -d: -f1)
        local slave_port=$(echo "$slave_data" | cut -d: -f2)
        local slave_user=$(echo "$slave_data" | cut -d: -f3)
        # 提取密码部分（可能包含加密数据中的冒号）
        local slave_pass=$(echo "$slave_data" | sed 's/^[^:]*:[^:]*:[^:]*://')
        
        # 解密密码（如果已加密）
        if [[ "$slave_pass" =~ ^ENC: ]]; then
            echo -e "${YELLOW}⚠️  从服务器密码仍为加密状态，尝试解密...${NC}"
            slave_pass=$(decrypt_sensitive_info "$slave_pass")
            if [ $? -ne 0 ]; then
                echo -e "${RED}❌ 从服务器密码解密失败${NC}"
                continue
            fi
        fi

        echo -e "${YELLOW}测试连接到从服务器: $slave_ip:$slave_port (用户: $slave_user)...${NC}"

        # 先尝试密码连接（非交互，使用已解析的 slave_pass）
        if sshpass -p "$slave_pass" ssh -p "$slave_port" \
            -o ConnectTimeout=10 -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null \
            -o PreferredAuthentications=password,keyboard-interactive -o PubkeyAuthentication=no \
            "$slave_user@$slave_ip" "echo 'SSH连接测试成功'" 2>/dev/null; then
            echo -e "${GREEN}✅ 连接到从服务器 $slave_ip 成功${NC}"
        else
            echo -e "${RED}❌ 连接到从服务器 $slave_ip 失败${NC}"
        fi
    done

    echo -e "${GREEN}✅ SSH连接测试完成${NC}"
}

stop_all_tasks() {
    echo -e "${YELLOW}关停所有同步任务...${NC}"
    # TODO: 实现关停所有任务逻辑
    echo -e "${GREEN}✅ 所有任务已关停${NC}"
}

uninstall_all_services() {
    echo -e "${RED}⚠️  警告：此操作将完全卸载同步服务${NC}"
    read -p "确认卸载？[y/N]: " confirm
    if [[ "$confirm" =~ ^[Yy]$ ]]; then
        echo -e "${YELLOW}正在卸载所有同步服务...${NC}"

        # 停止服务
        systemctl stop sync_tool 2>/dev/null
        systemctl disable sync_tool 2>/dev/null

        # 删除系统服务文件
        rm -f /etc/systemd/system/sync_tool.service
        systemctl daemon-reload

        # 停止所有相关进程
        pkill -f "inotifywait -m -r" 2>/dev/null
        pkill -f "sync_master.sh" 2>/dev/null
        pkill -f "sync_slave.sh" 2>/dev/null

        # 删除脚本文件
        rm -f /usr/local/bin/sync_master.sh
        rm -f /usr/local/bin/sync_slave.sh

        # 删除配置目录
        rm -rf "$CONFIG_DIR"

        # 删除日志文件
        rm -f /var/log/sync_tool/sync.log
        rm -f /var/log/sync_tool/recovery.log

        echo -e "${GREEN}✅ 所有服务已卸载${NC}"
    else
        echo -e "${CYAN}取消卸载${NC}"
    fi
}

# 主程序
main() {
    while true; do
        show_welcome
        show_main_menu
        read -p "请选择 [1-5]: " choice

        case $choice in
            1) setup_master_master_mode ;;
            2) setup_master_slave_mode ;;
            3) show_task_management ;;
            4) check_system_status ;;
            5)
                echo -e "\n${GREEN}感谢使用高级文件同步管理器！${NC}"
                exit 0
                ;;
            *)
                echo -e "${RED}❌ 无效选择，请重新输入${NC}"
                ;;
        esac

        echo -e "\n${YELLOW}按回车键继续...${NC}"
        read
    done
}

# 启动主程序
main "$@"
